mirror of
https://github.com/kodjodevf/mangayomi.git
synced 2026-01-11 22:40:36 +00:00
2572 lines
103 KiB
Rust
2572 lines
103 KiB
Rust
// This file is automatically generated, so please do not edit it.
|
|
// @generated by `flutter_rust_bridge`@ 2.11.1.
|
|
|
|
#![allow(
|
|
non_camel_case_types,
|
|
unused,
|
|
non_snake_case,
|
|
clippy::needless_return,
|
|
clippy::redundant_closure_call,
|
|
clippy::redundant_closure,
|
|
clippy::useless_conversion,
|
|
clippy::unit_arg,
|
|
clippy::unused_unit,
|
|
clippy::double_parens,
|
|
clippy::let_and_return,
|
|
clippy::too_many_arguments,
|
|
clippy::match_single_binding,
|
|
clippy::clone_on_copy,
|
|
clippy::let_unit_value,
|
|
clippy::deref_addrof,
|
|
clippy::explicit_auto_deref,
|
|
clippy::borrow_deref_ref,
|
|
clippy::needless_borrow
|
|
)]
|
|
|
|
// Section: imports
|
|
|
|
use crate::api::rhttp::client::*;
|
|
use crate::*;
|
|
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.11.1";
|
|
pub(crate) const FLUTTER_RUST_BRIDGE_CODEGEN_CONTENT_HASH: i32 = 885218533;
|
|
|
|
// Section: executor
|
|
|
|
flutter_rust_bridge::frb_generated_default_handler!();
|
|
|
|
// Section: wire_funcs
|
|
|
|
fn wire__crate__api__rhttp__http__cancel_request_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: "cancel_request",
|
|
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_token = <RustOpaqueMoi<
|
|
flutter_rust_bridge::for_generated::RustAutoOpaqueInner<CancellationToken>,
|
|
>>::sse_decode(&mut deserializer);
|
|
deserializer.end();
|
|
move |context| {
|
|
transform_result_sse::<_, ()>((move || {
|
|
let mut api_token_guard = None;
|
|
let decode_indices_ =
|
|
flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![
|
|
flutter_rust_bridge::for_generated::LockableOrderInfo::new(
|
|
&api_token, 0, false,
|
|
),
|
|
]);
|
|
for i in decode_indices_ {
|
|
match i {
|
|
0 => api_token_guard = Some(api_token.lockable_decode_sync_ref()),
|
|
_ => unreachable!(),
|
|
}
|
|
}
|
|
let api_token_guard = api_token_guard.unwrap();
|
|
let output_ok = Result::<_, ()>::Ok({
|
|
crate::api::rhttp::http::cancel_request(&*api_token_guard);
|
|
})?;
|
|
Ok(output_ok)
|
|
})())
|
|
}
|
|
},
|
|
)
|
|
}
|
|
fn wire__crate__api__rhttp__http__cancel_running_requests_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: "cancel_running_requests",
|
|
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_client = <RustOpaqueMoi<
|
|
flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RequestClient>,
|
|
>>::sse_decode(&mut deserializer);
|
|
deserializer.end();
|
|
move |context| {
|
|
transform_result_sse::<_, ()>((move || {
|
|
let mut api_client_guard = None;
|
|
let decode_indices_ =
|
|
flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![
|
|
flutter_rust_bridge::for_generated::LockableOrderInfo::new(
|
|
&api_client,
|
|
0,
|
|
false,
|
|
),
|
|
]);
|
|
for i in decode_indices_ {
|
|
match i {
|
|
0 => api_client_guard = Some(api_client.lockable_decode_sync_ref()),
|
|
_ => unreachable!(),
|
|
}
|
|
}
|
|
let api_client_guard = api_client_guard.unwrap();
|
|
let output_ok = Result::<_, ()>::Ok({
|
|
crate::api::rhttp::http::cancel_running_requests(&*api_client_guard);
|
|
})?;
|
|
Ok(output_ok)
|
|
})())
|
|
}
|
|
},
|
|
)
|
|
}
|
|
fn wire__crate__api__rhttp__client__client_settings_default_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: "client_settings_default",
|
|
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::rhttp::client::ClientSettings::default())?;
|
|
Ok(output_ok)
|
|
})())
|
|
}
|
|
},
|
|
)
|
|
}
|
|
fn wire__crate__api__rhttp__client__create_dynamic_resolver_sync_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_dynamic_resolver_sync",
|
|
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_resolver = decode_DartFn_Inputs_String_Output_list_String_AnyhowException(
|
|
<flutter_rust_bridge::DartOpaque>::sse_decode(&mut deserializer),
|
|
);
|
|
deserializer.end();
|
|
transform_result_sse::<_, ()>((move || {
|
|
let output_ok = Result::<_, ()>::Ok(
|
|
crate::api::rhttp::client::create_dynamic_resolver_sync(api_resolver),
|
|
)?;
|
|
Ok(output_ok)
|
|
})())
|
|
},
|
|
)
|
|
}
|
|
fn wire__crate__api__rhttp__client__create_static_resolver_sync_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_static_resolver_sync",
|
|
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_settings =
|
|
<crate::api::rhttp::client::StaticDnsSettings>::sse_decode(&mut deserializer);
|
|
deserializer.end();
|
|
transform_result_sse::<_, ()>((move || {
|
|
let output_ok = Result::<_, ()>::Ok(
|
|
crate::api::rhttp::client::create_static_resolver_sync(api_settings),
|
|
)?;
|
|
Ok(output_ok)
|
|
})())
|
|
},
|
|
)
|
|
}
|
|
fn wire__crate__api__rhttp__http__make_http_request_receive_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_async::<flutter_rust_bridge::for_generated::SseCodec,_,_,_>(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "make_http_request_receive_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);
|
|
let api_client = <Option<RustAutoOpaqueMoi<RequestClient>>>::sse_decode(&mut deserializer);
|
|
let api_settings = <Option<crate::api::rhttp::client::ClientSettings>>::sse_decode(&mut deserializer);
|
|
let api_method = <crate::api::rhttp::http::HttpMethod>::sse_decode(&mut deserializer);
|
|
let api_url = <String>::sse_decode(&mut deserializer);
|
|
let api_query = <Option<Vec<(String,String,)>>>::sse_decode(&mut deserializer);
|
|
let api_headers = <Option<crate::api::rhttp::http::HttpHeaders>>::sse_decode(&mut deserializer);
|
|
let api_body = <Option<Vec<u8>>>::sse_decode(&mut deserializer);
|
|
let api_stream_sink = <StreamSink<Vec<u8>,flutter_rust_bridge::for_generated::SseCodec>>::sse_decode(&mut deserializer);
|
|
let api_on_response = decode_DartFn_Inputs_http_response_Output_unit_AnyhowException(<flutter_rust_bridge::DartOpaque>::sse_decode(&mut deserializer));
|
|
let api_on_error = decode_DartFn_Inputs_rhttp_error_Output_unit_AnyhowException(<flutter_rust_bridge::DartOpaque>::sse_decode(&mut deserializer));
|
|
let api_on_cancel_token = decode_DartFn_Inputs_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerCancellationToken_Output_unit_AnyhowException(<flutter_rust_bridge::DartOpaque>::sse_decode(&mut deserializer));
|
|
let api_cancelable = <bool>::sse_decode(&mut deserializer);deserializer.end(); move |context| async move {
|
|
transform_result_sse::<_, crate::api::rhttp::error::RhttpError>((move || async move {
|
|
let output_ok = crate::api::rhttp::http::make_http_request_receive_stream(api_client, api_settings, api_method, api_url, api_query, api_headers, api_body, api_stream_sink, api_on_response, api_on_error, api_on_cancel_token, api_cancelable).await?; Ok(output_ok)
|
|
})().await)
|
|
} })
|
|
}
|
|
fn wire__crate__api__image__process_crop_image_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: "process_crop_image",
|
|
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_image = <Vec<u8>>::sse_decode(&mut deserializer);
|
|
deserializer.end();
|
|
transform_result_sse::<_, ()>((move || {
|
|
let output_ok =
|
|
Result::<_, ()>::Ok(crate::api::image::process_crop_image(api_image))?;
|
|
Ok(output_ok)
|
|
})())
|
|
},
|
|
)
|
|
}
|
|
fn wire__crate__api__rhttp__http__register_client_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: "register_client",
|
|
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_settings =
|
|
<crate::api::rhttp::client::ClientSettings>::sse_decode(&mut deserializer);
|
|
deserializer.end();
|
|
move |context| async move {
|
|
transform_result_sse::<_, crate::api::rhttp::error::RhttpError>(
|
|
(move || async move {
|
|
let output_ok =
|
|
crate::api::rhttp::http::register_client(api_settings).await?;
|
|
Ok(output_ok)
|
|
})()
|
|
.await,
|
|
)
|
|
}
|
|
},
|
|
)
|
|
}
|
|
fn wire__crate__api__rhttp__http__register_client_sync_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: "register_client_sync",
|
|
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_settings =
|
|
<crate::api::rhttp::client::ClientSettings>::sse_decode(&mut deserializer);
|
|
deserializer.end();
|
|
transform_result_sse::<_, crate::api::rhttp::error::RhttpError>((move || {
|
|
let output_ok = crate::api::rhttp::http::register_client_sync(api_settings)?;
|
|
Ok(output_ok)
|
|
})())
|
|
},
|
|
)
|
|
}
|
|
|
|
// Section: related_funcs
|
|
|
|
fn decode_DartFn_Inputs_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerCancellationToken_Output_unit_AnyhowException(
|
|
dart_opaque: flutter_rust_bridge::DartOpaque,
|
|
) -> impl Fn(CancellationToken) -> flutter_rust_bridge::DartFnFuture<()> {
|
|
use flutter_rust_bridge::IntoDart;
|
|
|
|
async fn body(dart_opaque: flutter_rust_bridge::DartOpaque, arg0: CancellationToken) -> () {
|
|
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: CancellationToken| {
|
|
flutter_rust_bridge::for_generated::convert_into_dart_fn_future(body(
|
|
dart_opaque.clone(),
|
|
arg0,
|
|
))
|
|
}
|
|
}
|
|
fn decode_DartFn_Inputs_String_Output_list_String_AnyhowException(
|
|
dart_opaque: flutter_rust_bridge::DartOpaque,
|
|
) -> impl Fn(String) -> flutter_rust_bridge::DartFnFuture<Vec<String>> {
|
|
use flutter_rust_bridge::IntoDart;
|
|
|
|
async fn body(dart_opaque: flutter_rust_bridge::DartOpaque, arg0: String) -> Vec<String> {
|
|
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(<Vec<String>>::sse_decode(&mut deserializer)),
|
|
1 => std::result::Result::Err(
|
|
<flutter_rust_bridge::for_generated::anyhow::Error>::sse_decode(&mut deserializer),
|
|
),
|
|
_ => unreachable!(),
|
|
};
|
|
deserializer.end();
|
|
let ans = ans.expect("Dart throws exception but Rust side assume it is not failable");
|
|
ans
|
|
}
|
|
|
|
move |arg0: String| {
|
|
flutter_rust_bridge::for_generated::convert_into_dart_fn_future(body(
|
|
dart_opaque.clone(),
|
|
arg0,
|
|
))
|
|
}
|
|
}
|
|
fn decode_DartFn_Inputs_http_response_Output_unit_AnyhowException(
|
|
dart_opaque: flutter_rust_bridge::DartOpaque,
|
|
) -> impl Fn(crate::api::rhttp::http::HttpResponse) -> flutter_rust_bridge::DartFnFuture<()> {
|
|
use flutter_rust_bridge::IntoDart;
|
|
|
|
async fn body(
|
|
dart_opaque: flutter_rust_bridge::DartOpaque,
|
|
arg0: crate::api::rhttp::http::HttpResponse,
|
|
) -> () {
|
|
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: crate::api::rhttp::http::HttpResponse| {
|
|
flutter_rust_bridge::for_generated::convert_into_dart_fn_future(body(
|
|
dart_opaque.clone(),
|
|
arg0,
|
|
))
|
|
}
|
|
}
|
|
fn decode_DartFn_Inputs_rhttp_error_Output_unit_AnyhowException(
|
|
dart_opaque: flutter_rust_bridge::DartOpaque,
|
|
) -> impl Fn(crate::api::rhttp::error::RhttpError) -> flutter_rust_bridge::DartFnFuture<()> {
|
|
use flutter_rust_bridge::IntoDart;
|
|
|
|
async fn body(
|
|
dart_opaque: flutter_rust_bridge::DartOpaque,
|
|
arg0: crate::api::rhttp::error::RhttpError,
|
|
) -> () {
|
|
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: crate::api::rhttp::error::RhttpError| {
|
|
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<CancellationToken>
|
|
);
|
|
flutter_rust_bridge::frb_generated_moi_arc_impl_value!(
|
|
flutter_rust_bridge::for_generated::RustAutoOpaqueInner<DnsSettings>
|
|
);
|
|
flutter_rust_bridge::frb_generated_moi_arc_impl_value!(
|
|
flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RequestClient>
|
|
);
|
|
|
|
// 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 RustAutoOpaqueMoi<RequestClient> {
|
|
// 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<RequestClient>,
|
|
>>::sse_decode(deserializer);
|
|
return flutter_rust_bridge::for_generated::rust_auto_opaque_explicit_decode(inner);
|
|
}
|
|
}
|
|
|
|
impl SseDecode for CancellationToken {
|
|
// 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<CancellationToken>,
|
|
>>::sse_decode(deserializer);
|
|
return flutter_rust_bridge::for_generated::rust_auto_opaque_decode_owned(inner);
|
|
}
|
|
}
|
|
|
|
impl SseDecode for DnsSettings {
|
|
// 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<DnsSettings>,
|
|
>>::sse_decode(deserializer);
|
|
return flutter_rust_bridge::for_generated::rust_auto_opaque_decode_owned(inner);
|
|
}
|
|
}
|
|
|
|
impl SseDecode for RequestClient {
|
|
// 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<RequestClient>,
|
|
>>::sse_decode(deserializer);
|
|
return flutter_rust_bridge::for_generated::rust_auto_opaque_decode_owned(inner);
|
|
}
|
|
}
|
|
|
|
impl SseDecode for chrono::Duration {
|
|
// 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 = <i64>::sse_decode(deserializer);
|
|
return chrono::Duration::microseconds(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, 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 inner = <Vec<(String, Vec<String>)>>::sse_decode(deserializer);
|
|
return inner.into_iter().collect();
|
|
}
|
|
}
|
|
|
|
impl SseDecode
|
|
for RustOpaqueMoi<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<CancellationToken>>
|
|
{
|
|
// 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<DnsSettings>>
|
|
{
|
|
// 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<RequestClient>>
|
|
{
|
|
// 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 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 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 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::rhttp::client::ClientCertificate {
|
|
// 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_certificate = <Vec<u8>>::sse_decode(deserializer);
|
|
let mut var_privateKey = <Vec<u8>>::sse_decode(deserializer);
|
|
return crate::api::rhttp::client::ClientCertificate {
|
|
certificate: var_certificate,
|
|
private_key: var_privateKey,
|
|
};
|
|
}
|
|
}
|
|
|
|
impl SseDecode for crate::api::rhttp::client::ClientSettings {
|
|
// 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_timeoutSettings =
|
|
<Option<crate::api::rhttp::client::TimeoutSettings>>::sse_decode(deserializer);
|
|
let mut var_throwOnStatusCode = <bool>::sse_decode(deserializer);
|
|
let mut var_proxySettings =
|
|
<Option<crate::api::rhttp::client::ProxySettings>>::sse_decode(deserializer);
|
|
let mut var_redirectSettings =
|
|
<Option<crate::api::rhttp::client::RedirectSettings>>::sse_decode(deserializer);
|
|
let mut var_tlsSettings =
|
|
<Option<crate::api::rhttp::client::TlsSettings>>::sse_decode(deserializer);
|
|
let mut var_dnsSettings = <Option<DnsSettings>>::sse_decode(deserializer);
|
|
return crate::api::rhttp::client::ClientSettings {
|
|
timeout_settings: var_timeoutSettings,
|
|
throw_on_status_code: var_throwOnStatusCode,
|
|
proxy_settings: var_proxySettings,
|
|
redirect_settings: var_redirectSettings,
|
|
tls_settings: var_tlsSettings,
|
|
dns_settings: var_dnsSettings,
|
|
};
|
|
}
|
|
}
|
|
|
|
impl SseDecode for crate::api::rhttp::client::CustomProxy {
|
|
// 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_url = <String>::sse_decode(deserializer);
|
|
let mut var_condition =
|
|
<crate::api::rhttp::client::ProxyCondition>::sse_decode(deserializer);
|
|
return crate::api::rhttp::client::CustomProxy {
|
|
url: var_url,
|
|
condition: var_condition,
|
|
};
|
|
}
|
|
}
|
|
|
|
impl SseDecode for crate::api::rhttp::http::HttpHeaders {
|
|
// 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_field0 =
|
|
<std::collections::HashMap<String, String>>::sse_decode(deserializer);
|
|
return crate::api::rhttp::http::HttpHeaders::Map(var_field0);
|
|
}
|
|
1 => {
|
|
let mut var_field0 = <Vec<(String, String)>>::sse_decode(deserializer);
|
|
return crate::api::rhttp::http::HttpHeaders::List(var_field0);
|
|
}
|
|
_ => {
|
|
unimplemented!("");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
impl SseDecode for crate::api::rhttp::http::HttpMethod {
|
|
// 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::rhttp::http::HttpMethod::Options,
|
|
1 => crate::api::rhttp::http::HttpMethod::Get,
|
|
2 => crate::api::rhttp::http::HttpMethod::Post,
|
|
3 => crate::api::rhttp::http::HttpMethod::Put,
|
|
4 => crate::api::rhttp::http::HttpMethod::Delete,
|
|
5 => crate::api::rhttp::http::HttpMethod::Head,
|
|
6 => crate::api::rhttp::http::HttpMethod::Trace,
|
|
7 => crate::api::rhttp::http::HttpMethod::Connect,
|
|
8 => crate::api::rhttp::http::HttpMethod::Patch,
|
|
_ => unreachable!("Invalid variant for HttpMethod: {}", inner),
|
|
};
|
|
}
|
|
}
|
|
|
|
impl SseDecode for crate::api::rhttp::http::HttpResponse {
|
|
// 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_headers = <Vec<(String, String)>>::sse_decode(deserializer);
|
|
let mut var_version = <crate::api::rhttp::http::HttpVersion>::sse_decode(deserializer);
|
|
let mut var_statusCode = <u16>::sse_decode(deserializer);
|
|
let mut var_body = <crate::api::rhttp::http::HttpResponseBody>::sse_decode(deserializer);
|
|
return crate::api::rhttp::http::HttpResponse {
|
|
headers: var_headers,
|
|
version: var_version,
|
|
status_code: var_statusCode,
|
|
body: var_body,
|
|
};
|
|
}
|
|
}
|
|
|
|
impl SseDecode for crate::api::rhttp::http::HttpResponseBody {
|
|
// 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_field0 = <String>::sse_decode(deserializer);
|
|
return crate::api::rhttp::http::HttpResponseBody::Text(var_field0);
|
|
}
|
|
1 => {
|
|
let mut var_field0 = <Vec<u8>>::sse_decode(deserializer);
|
|
return crate::api::rhttp::http::HttpResponseBody::Bytes(var_field0);
|
|
}
|
|
2 => {
|
|
return crate::api::rhttp::http::HttpResponseBody::Stream;
|
|
}
|
|
_ => {
|
|
unimplemented!("");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
impl SseDecode for crate::api::rhttp::http::HttpVersion {
|
|
// 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::rhttp::http::HttpVersion::Http09,
|
|
1 => crate::api::rhttp::http::HttpVersion::Http10,
|
|
2 => crate::api::rhttp::http::HttpVersion::Http11,
|
|
3 => crate::api::rhttp::http::HttpVersion::Other,
|
|
_ => unreachable!("Invalid variant for HttpVersion: {}", inner),
|
|
};
|
|
}
|
|
}
|
|
|
|
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 i64 {
|
|
// 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()
|
|
}
|
|
}
|
|
|
|
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 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![];
|
|
for idx_ in 0..len_ {
|
|
ans_.push(<String>::sse_decode(deserializer));
|
|
}
|
|
return ans_;
|
|
}
|
|
}
|
|
|
|
impl SseDecode for Vec<crate::api::rhttp::client::CustomProxy> {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
|
|
let mut len_ = <i32>::sse_decode(deserializer);
|
|
let mut ans_ = vec![];
|
|
for idx_ in 0..len_ {
|
|
ans_.push(<crate::api::rhttp::client::CustomProxy>::sse_decode(
|
|
deserializer,
|
|
));
|
|
}
|
|
return ans_;
|
|
}
|
|
}
|
|
|
|
impl SseDecode for Vec<Vec<u8>> {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
|
|
let mut len_ = <i32>::sse_decode(deserializer);
|
|
let mut ans_ = vec![];
|
|
for idx_ in 0..len_ {
|
|
ans_.push(<Vec<u8>>::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![];
|
|
for idx_ in 0..len_ {
|
|
ans_.push(<u8>::sse_decode(deserializer));
|
|
}
|
|
return ans_;
|
|
}
|
|
}
|
|
|
|
impl SseDecode for Vec<(String, 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![];
|
|
for idx_ in 0..len_ {
|
|
ans_.push(<(String, Vec<String>)>::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![];
|
|
for idx_ in 0..len_ {
|
|
ans_.push(<(String, String)>::sse_decode(deserializer));
|
|
}
|
|
return ans_;
|
|
}
|
|
}
|
|
|
|
impl SseDecode for Option<RustAutoOpaqueMoi<RequestClient>> {
|
|
// 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(<RustAutoOpaqueMoi<RequestClient>>::sse_decode(deserializer));
|
|
} else {
|
|
return None;
|
|
}
|
|
}
|
|
}
|
|
|
|
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<DnsSettings> {
|
|
// 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(<DnsSettings>::sse_decode(deserializer));
|
|
} else {
|
|
return None;
|
|
}
|
|
}
|
|
}
|
|
|
|
impl SseDecode for Option<chrono::Duration> {
|
|
// 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(<chrono::Duration>::sse_decode(deserializer));
|
|
} else {
|
|
return None;
|
|
}
|
|
}
|
|
}
|
|
|
|
impl SseDecode for Option<crate::api::rhttp::client::ClientCertificate> {
|
|
// 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::rhttp::client::ClientCertificate>::sse_decode(
|
|
deserializer,
|
|
));
|
|
} else {
|
|
return None;
|
|
}
|
|
}
|
|
}
|
|
|
|
impl SseDecode for Option<crate::api::rhttp::client::ClientSettings> {
|
|
// 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::rhttp::client::ClientSettings>::sse_decode(
|
|
deserializer,
|
|
));
|
|
} else {
|
|
return None;
|
|
}
|
|
}
|
|
}
|
|
|
|
impl SseDecode for Option<crate::api::rhttp::http::HttpHeaders> {
|
|
// 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::rhttp::http::HttpHeaders>::sse_decode(
|
|
deserializer,
|
|
));
|
|
} else {
|
|
return None;
|
|
}
|
|
}
|
|
}
|
|
|
|
impl SseDecode for Option<crate::api::rhttp::client::ProxySettings> {
|
|
// 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::rhttp::client::ProxySettings>::sse_decode(
|
|
deserializer,
|
|
));
|
|
} else {
|
|
return None;
|
|
}
|
|
}
|
|
}
|
|
|
|
impl SseDecode for Option<crate::api::rhttp::client::RedirectSettings> {
|
|
// 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::rhttp::client::RedirectSettings>::sse_decode(
|
|
deserializer,
|
|
));
|
|
} else {
|
|
return None;
|
|
}
|
|
}
|
|
}
|
|
|
|
impl SseDecode for Option<crate::api::rhttp::client::TimeoutSettings> {
|
|
// 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::rhttp::client::TimeoutSettings>::sse_decode(
|
|
deserializer,
|
|
));
|
|
} else {
|
|
return None;
|
|
}
|
|
}
|
|
}
|
|
|
|
impl SseDecode for Option<crate::api::rhttp::client::TlsSettings> {
|
|
// 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::rhttp::client::TlsSettings>::sse_decode(
|
|
deserializer,
|
|
));
|
|
} else {
|
|
return None;
|
|
}
|
|
}
|
|
}
|
|
|
|
impl SseDecode for Option<crate::api::rhttp::client::TlsVersion> {
|
|
// 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::rhttp::client::TlsVersion>::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 Option<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 {
|
|
if (<bool>::sse_decode(deserializer)) {
|
|
return Some(<Vec<(String, String)>>::sse_decode(deserializer));
|
|
} else {
|
|
return None;
|
|
}
|
|
}
|
|
}
|
|
|
|
impl SseDecode for crate::api::rhttp::client::ProxyCondition {
|
|
// 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::rhttp::client::ProxyCondition::Http,
|
|
1 => crate::api::rhttp::client::ProxyCondition::Https,
|
|
2 => crate::api::rhttp::client::ProxyCondition::All,
|
|
_ => unreachable!("Invalid variant for ProxyCondition: {}", inner),
|
|
};
|
|
}
|
|
}
|
|
|
|
impl SseDecode for crate::api::rhttp::client::ProxySettings {
|
|
// 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::rhttp::client::ProxySettings::NoProxy;
|
|
}
|
|
1 => {
|
|
let mut var_field0 =
|
|
<Vec<crate::api::rhttp::client::CustomProxy>>::sse_decode(deserializer);
|
|
return crate::api::rhttp::client::ProxySettings::CustomProxyList(var_field0);
|
|
}
|
|
_ => {
|
|
unimplemented!("");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
impl SseDecode for (String, 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 var_field0 = <String>::sse_decode(deserializer);
|
|
let mut var_field1 = <Vec<String>>::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::rhttp::client::RedirectSettings {
|
|
// 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::rhttp::client::RedirectSettings::NoRedirect;
|
|
}
|
|
1 => {
|
|
let mut var_field0 = <i32>::sse_decode(deserializer);
|
|
return crate::api::rhttp::client::RedirectSettings::LimitedRedirects(var_field0);
|
|
}
|
|
_ => {
|
|
unimplemented!("");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
impl SseDecode for crate::api::rhttp::error::RhttpError {
|
|
// 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::rhttp::error::RhttpError::RhttpCancelError;
|
|
}
|
|
1 => {
|
|
return crate::api::rhttp::error::RhttpError::RhttpTimeoutError;
|
|
}
|
|
2 => {
|
|
return crate::api::rhttp::error::RhttpError::RhttpRedirectError;
|
|
}
|
|
3 => {
|
|
let mut var_field0 = <u16>::sse_decode(deserializer);
|
|
let mut var_field1 = <Vec<(String, String)>>::sse_decode(deserializer);
|
|
let mut var_field2 =
|
|
<crate::api::rhttp::http::HttpResponseBody>::sse_decode(deserializer);
|
|
return crate::api::rhttp::error::RhttpError::RhttpStatusCodeError(
|
|
var_field0, var_field1, var_field2,
|
|
);
|
|
}
|
|
4 => {
|
|
let mut var_field0 = <String>::sse_decode(deserializer);
|
|
return crate::api::rhttp::error::RhttpError::RhttpInvalidCertificateError(
|
|
var_field0,
|
|
);
|
|
}
|
|
5 => {
|
|
let mut var_field0 = <String>::sse_decode(deserializer);
|
|
return crate::api::rhttp::error::RhttpError::RhttpConnectionError(var_field0);
|
|
}
|
|
6 => {
|
|
let mut var_field0 = <String>::sse_decode(deserializer);
|
|
return crate::api::rhttp::error::RhttpError::RhttpUnknownError(var_field0);
|
|
}
|
|
_ => {
|
|
unimplemented!("");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
impl SseDecode for crate::api::rhttp::client::StaticDnsSettings {
|
|
// 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_overrides =
|
|
<std::collections::HashMap<String, Vec<String>>>::sse_decode(deserializer);
|
|
let mut var_fallback = <Option<String>>::sse_decode(deserializer);
|
|
return crate::api::rhttp::client::StaticDnsSettings {
|
|
overrides: var_overrides,
|
|
fallback: var_fallback,
|
|
};
|
|
}
|
|
}
|
|
|
|
impl SseDecode for crate::api::rhttp::client::TimeoutSettings {
|
|
// 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_timeout = <Option<chrono::Duration>>::sse_decode(deserializer);
|
|
let mut var_connectTimeout = <Option<chrono::Duration>>::sse_decode(deserializer);
|
|
let mut var_keepAliveTimeout = <Option<chrono::Duration>>::sse_decode(deserializer);
|
|
let mut var_keepAlivePing = <Option<chrono::Duration>>::sse_decode(deserializer);
|
|
return crate::api::rhttp::client::TimeoutSettings {
|
|
timeout: var_timeout,
|
|
connect_timeout: var_connectTimeout,
|
|
keep_alive_timeout: var_keepAliveTimeout,
|
|
keep_alive_ping: var_keepAlivePing,
|
|
};
|
|
}
|
|
}
|
|
|
|
impl SseDecode for crate::api::rhttp::client::TlsSettings {
|
|
// 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_trustRootCertificates = <bool>::sse_decode(deserializer);
|
|
let mut var_trustedRootCertificates = <Vec<Vec<u8>>>::sse_decode(deserializer);
|
|
let mut var_verifyCertificates = <bool>::sse_decode(deserializer);
|
|
let mut var_clientCertificate =
|
|
<Option<crate::api::rhttp::client::ClientCertificate>>::sse_decode(deserializer);
|
|
let mut var_minTlsVersion =
|
|
<Option<crate::api::rhttp::client::TlsVersion>>::sse_decode(deserializer);
|
|
let mut var_maxTlsVersion =
|
|
<Option<crate::api::rhttp::client::TlsVersion>>::sse_decode(deserializer);
|
|
return crate::api::rhttp::client::TlsSettings {
|
|
trust_root_certificates: var_trustRootCertificates,
|
|
trusted_root_certificates: var_trustedRootCertificates,
|
|
verify_certificates: var_verifyCertificates,
|
|
client_certificate: var_clientCertificate,
|
|
min_tls_version: var_minTlsVersion,
|
|
max_tls_version: var_maxTlsVersion,
|
|
};
|
|
}
|
|
}
|
|
|
|
impl SseDecode for crate::api::rhttp::client::TlsVersion {
|
|
// 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::rhttp::client::TlsVersion::Tls1_2,
|
|
1 => crate::api::rhttp::client::TlsVersion::Tls1_3,
|
|
_ => unreachable!("Invalid variant for TlsVersion: {}", inner),
|
|
};
|
|
}
|
|
}
|
|
|
|
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 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 _
|
|
}
|
|
}
|
|
|
|
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 {
|
|
2 => wire__crate__api__rhttp__http__cancel_request_impl(port, ptr, rust_vec_len, data_len),
|
|
3 => wire__crate__api__rhttp__http__cancel_running_requests_impl(
|
|
port,
|
|
ptr,
|
|
rust_vec_len,
|
|
data_len,
|
|
),
|
|
4 => wire__crate__api__rhttp__client__client_settings_default_impl(
|
|
port,
|
|
ptr,
|
|
rust_vec_len,
|
|
data_len,
|
|
),
|
|
7 => wire__crate__api__rhttp__http__make_http_request_receive_stream_impl(
|
|
port,
|
|
ptr,
|
|
rust_vec_len,
|
|
data_len,
|
|
),
|
|
9 => wire__crate__api__rhttp__http__register_client_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 {
|
|
5 => wire__crate__api__rhttp__client__create_dynamic_resolver_sync_impl(
|
|
ptr,
|
|
rust_vec_len,
|
|
data_len,
|
|
),
|
|
6 => wire__crate__api__rhttp__client__create_static_resolver_sync_impl(
|
|
ptr,
|
|
rust_vec_len,
|
|
data_len,
|
|
),
|
|
8 => wire__crate__api__image__process_crop_image_impl(ptr, rust_vec_len, data_len),
|
|
10 => wire__crate__api__rhttp__http__register_client_sync_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<CancellationToken> {
|
|
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<CancellationToken> {}
|
|
|
|
impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<CancellationToken>> for CancellationToken {
|
|
fn into_into_dart(self) -> FrbWrapper<CancellationToken> {
|
|
self.into()
|
|
}
|
|
}
|
|
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
impl flutter_rust_bridge::IntoDart for FrbWrapper<DnsSettings> {
|
|
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<DnsSettings> {}
|
|
|
|
impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<DnsSettings>> for DnsSettings {
|
|
fn into_into_dart(self) -> FrbWrapper<DnsSettings> {
|
|
self.into()
|
|
}
|
|
}
|
|
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
impl flutter_rust_bridge::IntoDart for FrbWrapper<RequestClient> {
|
|
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<RequestClient> {}
|
|
|
|
impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<RequestClient>> for RequestClient {
|
|
fn into_into_dart(self) -> FrbWrapper<RequestClient> {
|
|
self.into()
|
|
}
|
|
}
|
|
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
impl flutter_rust_bridge::IntoDart for crate::api::rhttp::client::ClientCertificate {
|
|
fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
|
|
[
|
|
self.certificate.into_into_dart().into_dart(),
|
|
self.private_key.into_into_dart().into_dart(),
|
|
]
|
|
.into_dart()
|
|
}
|
|
}
|
|
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
|
|
for crate::api::rhttp::client::ClientCertificate
|
|
{
|
|
}
|
|
impl flutter_rust_bridge::IntoIntoDart<crate::api::rhttp::client::ClientCertificate>
|
|
for crate::api::rhttp::client::ClientCertificate
|
|
{
|
|
fn into_into_dart(self) -> crate::api::rhttp::client::ClientCertificate {
|
|
self
|
|
}
|
|
}
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
impl flutter_rust_bridge::IntoDart for crate::api::rhttp::client::ClientSettings {
|
|
fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
|
|
[
|
|
self.timeout_settings.into_into_dart().into_dart(),
|
|
self.throw_on_status_code.into_into_dart().into_dart(),
|
|
self.proxy_settings.into_into_dart().into_dart(),
|
|
self.redirect_settings.into_into_dart().into_dart(),
|
|
self.tls_settings.into_into_dart().into_dart(),
|
|
self.dns_settings.into_into_dart().into_dart(),
|
|
]
|
|
.into_dart()
|
|
}
|
|
}
|
|
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
|
|
for crate::api::rhttp::client::ClientSettings
|
|
{
|
|
}
|
|
impl flutter_rust_bridge::IntoIntoDart<crate::api::rhttp::client::ClientSettings>
|
|
for crate::api::rhttp::client::ClientSettings
|
|
{
|
|
fn into_into_dart(self) -> crate::api::rhttp::client::ClientSettings {
|
|
self
|
|
}
|
|
}
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
impl flutter_rust_bridge::IntoDart for crate::api::rhttp::client::CustomProxy {
|
|
fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
|
|
[
|
|
self.url.into_into_dart().into_dart(),
|
|
self.condition.into_into_dart().into_dart(),
|
|
]
|
|
.into_dart()
|
|
}
|
|
}
|
|
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
|
|
for crate::api::rhttp::client::CustomProxy
|
|
{
|
|
}
|
|
impl flutter_rust_bridge::IntoIntoDart<crate::api::rhttp::client::CustomProxy>
|
|
for crate::api::rhttp::client::CustomProxy
|
|
{
|
|
fn into_into_dart(self) -> crate::api::rhttp::client::CustomProxy {
|
|
self
|
|
}
|
|
}
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
impl flutter_rust_bridge::IntoDart for crate::api::rhttp::http::HttpHeaders {
|
|
fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
|
|
match self {
|
|
crate::api::rhttp::http::HttpHeaders::Map(field0) => {
|
|
[0.into_dart(), field0.into_into_dart().into_dart()].into_dart()
|
|
}
|
|
crate::api::rhttp::http::HttpHeaders::List(field0) => {
|
|
[1.into_dart(), field0.into_into_dart().into_dart()].into_dart()
|
|
}
|
|
_ => {
|
|
unimplemented!("");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
|
|
for crate::api::rhttp::http::HttpHeaders
|
|
{
|
|
}
|
|
impl flutter_rust_bridge::IntoIntoDart<crate::api::rhttp::http::HttpHeaders>
|
|
for crate::api::rhttp::http::HttpHeaders
|
|
{
|
|
fn into_into_dart(self) -> crate::api::rhttp::http::HttpHeaders {
|
|
self
|
|
}
|
|
}
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
impl flutter_rust_bridge::IntoDart for crate::api::rhttp::http::HttpMethod {
|
|
fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
|
|
match self {
|
|
Self::Options => 0.into_dart(),
|
|
Self::Get => 1.into_dart(),
|
|
Self::Post => 2.into_dart(),
|
|
Self::Put => 3.into_dart(),
|
|
Self::Delete => 4.into_dart(),
|
|
Self::Head => 5.into_dart(),
|
|
Self::Trace => 6.into_dart(),
|
|
Self::Connect => 7.into_dart(),
|
|
Self::Patch => 8.into_dart(),
|
|
_ => unreachable!(),
|
|
}
|
|
}
|
|
}
|
|
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
|
|
for crate::api::rhttp::http::HttpMethod
|
|
{
|
|
}
|
|
impl flutter_rust_bridge::IntoIntoDart<crate::api::rhttp::http::HttpMethod>
|
|
for crate::api::rhttp::http::HttpMethod
|
|
{
|
|
fn into_into_dart(self) -> crate::api::rhttp::http::HttpMethod {
|
|
self
|
|
}
|
|
}
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
impl flutter_rust_bridge::IntoDart for crate::api::rhttp::http::HttpResponse {
|
|
fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
|
|
[
|
|
self.headers.into_into_dart().into_dart(),
|
|
self.version.into_into_dart().into_dart(),
|
|
self.status_code.into_into_dart().into_dart(),
|
|
self.body.into_into_dart().into_dart(),
|
|
]
|
|
.into_dart()
|
|
}
|
|
}
|
|
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
|
|
for crate::api::rhttp::http::HttpResponse
|
|
{
|
|
}
|
|
impl flutter_rust_bridge::IntoIntoDart<crate::api::rhttp::http::HttpResponse>
|
|
for crate::api::rhttp::http::HttpResponse
|
|
{
|
|
fn into_into_dart(self) -> crate::api::rhttp::http::HttpResponse {
|
|
self
|
|
}
|
|
}
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
impl flutter_rust_bridge::IntoDart for crate::api::rhttp::http::HttpResponseBody {
|
|
fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
|
|
match self {
|
|
crate::api::rhttp::http::HttpResponseBody::Text(field0) => {
|
|
[0.into_dart(), field0.into_into_dart().into_dart()].into_dart()
|
|
}
|
|
crate::api::rhttp::http::HttpResponseBody::Bytes(field0) => {
|
|
[1.into_dart(), field0.into_into_dart().into_dart()].into_dart()
|
|
}
|
|
crate::api::rhttp::http::HttpResponseBody::Stream => [2.into_dart()].into_dart(),
|
|
_ => {
|
|
unimplemented!("");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
|
|
for crate::api::rhttp::http::HttpResponseBody
|
|
{
|
|
}
|
|
impl flutter_rust_bridge::IntoIntoDart<crate::api::rhttp::http::HttpResponseBody>
|
|
for crate::api::rhttp::http::HttpResponseBody
|
|
{
|
|
fn into_into_dart(self) -> crate::api::rhttp::http::HttpResponseBody {
|
|
self
|
|
}
|
|
}
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
impl flutter_rust_bridge::IntoDart for crate::api::rhttp::http::HttpVersion {
|
|
fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
|
|
match self {
|
|
Self::Http09 => 0.into_dart(),
|
|
Self::Http10 => 1.into_dart(),
|
|
Self::Http11 => 2.into_dart(),
|
|
Self::Other => 3.into_dart(),
|
|
_ => unreachable!(),
|
|
}
|
|
}
|
|
}
|
|
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
|
|
for crate::api::rhttp::http::HttpVersion
|
|
{
|
|
}
|
|
impl flutter_rust_bridge::IntoIntoDart<crate::api::rhttp::http::HttpVersion>
|
|
for crate::api::rhttp::http::HttpVersion
|
|
{
|
|
fn into_into_dart(self) -> crate::api::rhttp::http::HttpVersion {
|
|
self
|
|
}
|
|
}
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
impl flutter_rust_bridge::IntoDart for crate::api::rhttp::client::ProxyCondition {
|
|
fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
|
|
match self {
|
|
Self::Http => 0.into_dart(),
|
|
Self::Https => 1.into_dart(),
|
|
Self::All => 2.into_dart(),
|
|
_ => unreachable!(),
|
|
}
|
|
}
|
|
}
|
|
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
|
|
for crate::api::rhttp::client::ProxyCondition
|
|
{
|
|
}
|
|
impl flutter_rust_bridge::IntoIntoDart<crate::api::rhttp::client::ProxyCondition>
|
|
for crate::api::rhttp::client::ProxyCondition
|
|
{
|
|
fn into_into_dart(self) -> crate::api::rhttp::client::ProxyCondition {
|
|
self
|
|
}
|
|
}
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
impl flutter_rust_bridge::IntoDart for crate::api::rhttp::client::ProxySettings {
|
|
fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
|
|
match self {
|
|
crate::api::rhttp::client::ProxySettings::NoProxy => [0.into_dart()].into_dart(),
|
|
crate::api::rhttp::client::ProxySettings::CustomProxyList(field0) => {
|
|
[1.into_dart(), field0.into_into_dart().into_dart()].into_dart()
|
|
}
|
|
_ => {
|
|
unimplemented!("");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
|
|
for crate::api::rhttp::client::ProxySettings
|
|
{
|
|
}
|
|
impl flutter_rust_bridge::IntoIntoDart<crate::api::rhttp::client::ProxySettings>
|
|
for crate::api::rhttp::client::ProxySettings
|
|
{
|
|
fn into_into_dart(self) -> crate::api::rhttp::client::ProxySettings {
|
|
self
|
|
}
|
|
}
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
impl flutter_rust_bridge::IntoDart for crate::api::rhttp::client::RedirectSettings {
|
|
fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
|
|
match self {
|
|
crate::api::rhttp::client::RedirectSettings::NoRedirect => [0.into_dart()].into_dart(),
|
|
crate::api::rhttp::client::RedirectSettings::LimitedRedirects(field0) => {
|
|
[1.into_dart(), field0.into_into_dart().into_dart()].into_dart()
|
|
}
|
|
_ => {
|
|
unimplemented!("");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
|
|
for crate::api::rhttp::client::RedirectSettings
|
|
{
|
|
}
|
|
impl flutter_rust_bridge::IntoIntoDart<crate::api::rhttp::client::RedirectSettings>
|
|
for crate::api::rhttp::client::RedirectSettings
|
|
{
|
|
fn into_into_dart(self) -> crate::api::rhttp::client::RedirectSettings {
|
|
self
|
|
}
|
|
}
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
impl flutter_rust_bridge::IntoDart for crate::api::rhttp::error::RhttpError {
|
|
fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
|
|
match self {
|
|
crate::api::rhttp::error::RhttpError::RhttpCancelError => [0.into_dart()].into_dart(),
|
|
crate::api::rhttp::error::RhttpError::RhttpTimeoutError => [1.into_dart()].into_dart(),
|
|
crate::api::rhttp::error::RhttpError::RhttpRedirectError => [2.into_dart()].into_dart(),
|
|
crate::api::rhttp::error::RhttpError::RhttpStatusCodeError(field0, field1, field2) => [
|
|
3.into_dart(),
|
|
field0.into_into_dart().into_dart(),
|
|
field1.into_into_dart().into_dart(),
|
|
field2.into_into_dart().into_dart(),
|
|
]
|
|
.into_dart(),
|
|
crate::api::rhttp::error::RhttpError::RhttpInvalidCertificateError(field0) => {
|
|
[4.into_dart(), field0.into_into_dart().into_dart()].into_dart()
|
|
}
|
|
crate::api::rhttp::error::RhttpError::RhttpConnectionError(field0) => {
|
|
[5.into_dart(), field0.into_into_dart().into_dart()].into_dart()
|
|
}
|
|
crate::api::rhttp::error::RhttpError::RhttpUnknownError(field0) => {
|
|
[6.into_dart(), field0.into_into_dart().into_dart()].into_dart()
|
|
}
|
|
_ => {
|
|
unimplemented!("");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
|
|
for crate::api::rhttp::error::RhttpError
|
|
{
|
|
}
|
|
impl flutter_rust_bridge::IntoIntoDart<crate::api::rhttp::error::RhttpError>
|
|
for crate::api::rhttp::error::RhttpError
|
|
{
|
|
fn into_into_dart(self) -> crate::api::rhttp::error::RhttpError {
|
|
self
|
|
}
|
|
}
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
impl flutter_rust_bridge::IntoDart for crate::api::rhttp::client::StaticDnsSettings {
|
|
fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
|
|
[
|
|
self.overrides.into_into_dart().into_dart(),
|
|
self.fallback.into_into_dart().into_dart(),
|
|
]
|
|
.into_dart()
|
|
}
|
|
}
|
|
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
|
|
for crate::api::rhttp::client::StaticDnsSettings
|
|
{
|
|
}
|
|
impl flutter_rust_bridge::IntoIntoDart<crate::api::rhttp::client::StaticDnsSettings>
|
|
for crate::api::rhttp::client::StaticDnsSettings
|
|
{
|
|
fn into_into_dart(self) -> crate::api::rhttp::client::StaticDnsSettings {
|
|
self
|
|
}
|
|
}
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
impl flutter_rust_bridge::IntoDart for crate::api::rhttp::client::TimeoutSettings {
|
|
fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
|
|
[
|
|
self.timeout.into_into_dart().into_dart(),
|
|
self.connect_timeout.into_into_dart().into_dart(),
|
|
self.keep_alive_timeout.into_into_dart().into_dart(),
|
|
self.keep_alive_ping.into_into_dart().into_dart(),
|
|
]
|
|
.into_dart()
|
|
}
|
|
}
|
|
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
|
|
for crate::api::rhttp::client::TimeoutSettings
|
|
{
|
|
}
|
|
impl flutter_rust_bridge::IntoIntoDart<crate::api::rhttp::client::TimeoutSettings>
|
|
for crate::api::rhttp::client::TimeoutSettings
|
|
{
|
|
fn into_into_dart(self) -> crate::api::rhttp::client::TimeoutSettings {
|
|
self
|
|
}
|
|
}
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
impl flutter_rust_bridge::IntoDart for crate::api::rhttp::client::TlsSettings {
|
|
fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
|
|
[
|
|
self.trust_root_certificates.into_into_dart().into_dart(),
|
|
self.trusted_root_certificates.into_into_dart().into_dart(),
|
|
self.verify_certificates.into_into_dart().into_dart(),
|
|
self.client_certificate.into_into_dart().into_dart(),
|
|
self.min_tls_version.into_into_dart().into_dart(),
|
|
self.max_tls_version.into_into_dart().into_dart(),
|
|
]
|
|
.into_dart()
|
|
}
|
|
}
|
|
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
|
|
for crate::api::rhttp::client::TlsSettings
|
|
{
|
|
}
|
|
impl flutter_rust_bridge::IntoIntoDart<crate::api::rhttp::client::TlsSettings>
|
|
for crate::api::rhttp::client::TlsSettings
|
|
{
|
|
fn into_into_dart(self) -> crate::api::rhttp::client::TlsSettings {
|
|
self
|
|
}
|
|
}
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
impl flutter_rust_bridge::IntoDart for crate::api::rhttp::client::TlsVersion {
|
|
fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
|
|
match self {
|
|
Self::Tls1_2 => 0.into_dart(),
|
|
Self::Tls1_3 => 1.into_dart(),
|
|
_ => unreachable!(),
|
|
}
|
|
}
|
|
}
|
|
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
|
|
for crate::api::rhttp::client::TlsVersion
|
|
{
|
|
}
|
|
impl flutter_rust_bridge::IntoIntoDart<crate::api::rhttp::client::TlsVersion>
|
|
for crate::api::rhttp::client::TlsVersion
|
|
{
|
|
fn into_into_dart(self) -> crate::api::rhttp::client::TlsVersion {
|
|
self
|
|
}
|
|
}
|
|
|
|
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 RustAutoOpaqueMoi<RequestClient> {
|
|
// 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<RequestClient>>>::sse_encode(flutter_rust_bridge::for_generated::rust_auto_opaque_explicit_encode(self), serializer);
|
|
}
|
|
}
|
|
|
|
impl SseEncode for CancellationToken {
|
|
// 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<CancellationToken>>>::sse_encode(flutter_rust_bridge::for_generated::rust_auto_opaque_encode::<_, MoiArc<_>>(self), serializer);
|
|
}
|
|
}
|
|
|
|
impl SseEncode for DnsSettings {
|
|
// 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<DnsSettings>>>::sse_encode(flutter_rust_bridge::for_generated::rust_auto_opaque_encode::<_, MoiArc<_>>(self), serializer);
|
|
}
|
|
}
|
|
|
|
impl SseEncode for RequestClient {
|
|
// 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<RequestClient>>>::sse_encode(flutter_rust_bridge::for_generated::rust_auto_opaque_encode::<_, MoiArc<_>>(self), serializer);
|
|
}
|
|
}
|
|
|
|
impl SseEncode for chrono::Duration {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
|
|
<i64>::sse_encode(
|
|
self.num_microseconds()
|
|
.expect("cannot get microseconds from time"),
|
|
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, Vec<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, Vec<String>)>>::sse_encode(self.into_iter().collect(), serializer);
|
|
}
|
|
}
|
|
|
|
impl SseEncode
|
|
for RustOpaqueMoi<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<CancellationToken>>
|
|
{
|
|
// 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<DnsSettings>>
|
|
{
|
|
// 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<RequestClient>>
|
|
{
|
|
// 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 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 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 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::rhttp::client::ClientCertificate {
|
|
// 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.certificate, serializer);
|
|
<Vec<u8>>::sse_encode(self.private_key, serializer);
|
|
}
|
|
}
|
|
|
|
impl SseEncode for crate::api::rhttp::client::ClientSettings {
|
|
// 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::rhttp::client::TimeoutSettings>>::sse_encode(
|
|
self.timeout_settings,
|
|
serializer,
|
|
);
|
|
<bool>::sse_encode(self.throw_on_status_code, serializer);
|
|
<Option<crate::api::rhttp::client::ProxySettings>>::sse_encode(
|
|
self.proxy_settings,
|
|
serializer,
|
|
);
|
|
<Option<crate::api::rhttp::client::RedirectSettings>>::sse_encode(
|
|
self.redirect_settings,
|
|
serializer,
|
|
);
|
|
<Option<crate::api::rhttp::client::TlsSettings>>::sse_encode(self.tls_settings, serializer);
|
|
<Option<DnsSettings>>::sse_encode(self.dns_settings, serializer);
|
|
}
|
|
}
|
|
|
|
impl SseEncode for crate::api::rhttp::client::CustomProxy {
|
|
// 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.url, serializer);
|
|
<crate::api::rhttp::client::ProxyCondition>::sse_encode(self.condition, serializer);
|
|
}
|
|
}
|
|
|
|
impl SseEncode for crate::api::rhttp::http::HttpHeaders {
|
|
// 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::rhttp::http::HttpHeaders::Map(field0) => {
|
|
<i32>::sse_encode(0, serializer);
|
|
<std::collections::HashMap<String, String>>::sse_encode(field0, serializer);
|
|
}
|
|
crate::api::rhttp::http::HttpHeaders::List(field0) => {
|
|
<i32>::sse_encode(1, serializer);
|
|
<Vec<(String, String)>>::sse_encode(field0, serializer);
|
|
}
|
|
_ => {
|
|
unimplemented!("");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
impl SseEncode for crate::api::rhttp::http::HttpMethod {
|
|
// 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::rhttp::http::HttpMethod::Options => 0,
|
|
crate::api::rhttp::http::HttpMethod::Get => 1,
|
|
crate::api::rhttp::http::HttpMethod::Post => 2,
|
|
crate::api::rhttp::http::HttpMethod::Put => 3,
|
|
crate::api::rhttp::http::HttpMethod::Delete => 4,
|
|
crate::api::rhttp::http::HttpMethod::Head => 5,
|
|
crate::api::rhttp::http::HttpMethod::Trace => 6,
|
|
crate::api::rhttp::http::HttpMethod::Connect => 7,
|
|
crate::api::rhttp::http::HttpMethod::Patch => 8,
|
|
_ => {
|
|
unimplemented!("");
|
|
}
|
|
},
|
|
serializer,
|
|
);
|
|
}
|
|
}
|
|
|
|
impl SseEncode for crate::api::rhttp::http::HttpResponse {
|
|
// 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.headers, serializer);
|
|
<crate::api::rhttp::http::HttpVersion>::sse_encode(self.version, serializer);
|
|
<u16>::sse_encode(self.status_code, serializer);
|
|
<crate::api::rhttp::http::HttpResponseBody>::sse_encode(self.body, serializer);
|
|
}
|
|
}
|
|
|
|
impl SseEncode for crate::api::rhttp::http::HttpResponseBody {
|
|
// 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::rhttp::http::HttpResponseBody::Text(field0) => {
|
|
<i32>::sse_encode(0, serializer);
|
|
<String>::sse_encode(field0, serializer);
|
|
}
|
|
crate::api::rhttp::http::HttpResponseBody::Bytes(field0) => {
|
|
<i32>::sse_encode(1, serializer);
|
|
<Vec<u8>>::sse_encode(field0, serializer);
|
|
}
|
|
crate::api::rhttp::http::HttpResponseBody::Stream => {
|
|
<i32>::sse_encode(2, serializer);
|
|
}
|
|
_ => {
|
|
unimplemented!("");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
impl SseEncode for crate::api::rhttp::http::HttpVersion {
|
|
// 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::rhttp::http::HttpVersion::Http09 => 0,
|
|
crate::api::rhttp::http::HttpVersion::Http10 => 1,
|
|
crate::api::rhttp::http::HttpVersion::Http11 => 2,
|
|
crate::api::rhttp::http::HttpVersion::Other => 3,
|
|
_ => {
|
|
unimplemented!("");
|
|
}
|
|
},
|
|
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 i64 {
|
|
// 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).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 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::rhttp::client::CustomProxy> {
|
|
// 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::rhttp::client::CustomProxy>::sse_encode(item, serializer);
|
|
}
|
|
}
|
|
}
|
|
|
|
impl SseEncode for Vec<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 {
|
|
<Vec<u8>>::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, 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, Vec<String>)>::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 Option<RustAutoOpaqueMoi<RequestClient>> {
|
|
// 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 {
|
|
<RustAutoOpaqueMoi<RequestClient>>::sse_encode(value, 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<DnsSettings> {
|
|
// 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 {
|
|
<DnsSettings>::sse_encode(value, serializer);
|
|
}
|
|
}
|
|
}
|
|
|
|
impl SseEncode for Option<chrono::Duration> {
|
|
// 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 {
|
|
<chrono::Duration>::sse_encode(value, serializer);
|
|
}
|
|
}
|
|
}
|
|
|
|
impl SseEncode for Option<crate::api::rhttp::client::ClientCertificate> {
|
|
// 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::rhttp::client::ClientCertificate>::sse_encode(value, serializer);
|
|
}
|
|
}
|
|
}
|
|
|
|
impl SseEncode for Option<crate::api::rhttp::client::ClientSettings> {
|
|
// 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::rhttp::client::ClientSettings>::sse_encode(value, serializer);
|
|
}
|
|
}
|
|
}
|
|
|
|
impl SseEncode for Option<crate::api::rhttp::http::HttpHeaders> {
|
|
// 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::rhttp::http::HttpHeaders>::sse_encode(value, serializer);
|
|
}
|
|
}
|
|
}
|
|
|
|
impl SseEncode for Option<crate::api::rhttp::client::ProxySettings> {
|
|
// 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::rhttp::client::ProxySettings>::sse_encode(value, serializer);
|
|
}
|
|
}
|
|
}
|
|
|
|
impl SseEncode for Option<crate::api::rhttp::client::RedirectSettings> {
|
|
// 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::rhttp::client::RedirectSettings>::sse_encode(value, serializer);
|
|
}
|
|
}
|
|
}
|
|
|
|
impl SseEncode for Option<crate::api::rhttp::client::TimeoutSettings> {
|
|
// 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::rhttp::client::TimeoutSettings>::sse_encode(value, serializer);
|
|
}
|
|
}
|
|
}
|
|
|
|
impl SseEncode for Option<crate::api::rhttp::client::TlsSettings> {
|
|
// 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::rhttp::client::TlsSettings>::sse_encode(value, serializer);
|
|
}
|
|
}
|
|
}
|
|
|
|
impl SseEncode for Option<crate::api::rhttp::client::TlsVersion> {
|
|
// 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::rhttp::client::TlsVersion>::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 Option<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) {
|
|
<bool>::sse_encode(self.is_some(), serializer);
|
|
if let Some(value) = self {
|
|
<Vec<(String, String)>>::sse_encode(value, serializer);
|
|
}
|
|
}
|
|
}
|
|
|
|
impl SseEncode for crate::api::rhttp::client::ProxyCondition {
|
|
// 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::rhttp::client::ProxyCondition::Http => 0,
|
|
crate::api::rhttp::client::ProxyCondition::Https => 1,
|
|
crate::api::rhttp::client::ProxyCondition::All => 2,
|
|
_ => {
|
|
unimplemented!("");
|
|
}
|
|
},
|
|
serializer,
|
|
);
|
|
}
|
|
}
|
|
|
|
impl SseEncode for crate::api::rhttp::client::ProxySettings {
|
|
// 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::rhttp::client::ProxySettings::NoProxy => {
|
|
<i32>::sse_encode(0, serializer);
|
|
}
|
|
crate::api::rhttp::client::ProxySettings::CustomProxyList(field0) => {
|
|
<i32>::sse_encode(1, serializer);
|
|
<Vec<crate::api::rhttp::client::CustomProxy>>::sse_encode(field0, serializer);
|
|
}
|
|
_ => {
|
|
unimplemented!("");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
impl SseEncode for (String, Vec<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);
|
|
<Vec<String>>::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::rhttp::client::RedirectSettings {
|
|
// 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::rhttp::client::RedirectSettings::NoRedirect => {
|
|
<i32>::sse_encode(0, serializer);
|
|
}
|
|
crate::api::rhttp::client::RedirectSettings::LimitedRedirects(field0) => {
|
|
<i32>::sse_encode(1, serializer);
|
|
<i32>::sse_encode(field0, serializer);
|
|
}
|
|
_ => {
|
|
unimplemented!("");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
impl SseEncode for crate::api::rhttp::error::RhttpError {
|
|
// 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::rhttp::error::RhttpError::RhttpCancelError => {
|
|
<i32>::sse_encode(0, serializer);
|
|
}
|
|
crate::api::rhttp::error::RhttpError::RhttpTimeoutError => {
|
|
<i32>::sse_encode(1, serializer);
|
|
}
|
|
crate::api::rhttp::error::RhttpError::RhttpRedirectError => {
|
|
<i32>::sse_encode(2, serializer);
|
|
}
|
|
crate::api::rhttp::error::RhttpError::RhttpStatusCodeError(field0, field1, field2) => {
|
|
<i32>::sse_encode(3, serializer);
|
|
<u16>::sse_encode(field0, serializer);
|
|
<Vec<(String, String)>>::sse_encode(field1, serializer);
|
|
<crate::api::rhttp::http::HttpResponseBody>::sse_encode(field2, serializer);
|
|
}
|
|
crate::api::rhttp::error::RhttpError::RhttpInvalidCertificateError(field0) => {
|
|
<i32>::sse_encode(4, serializer);
|
|
<String>::sse_encode(field0, serializer);
|
|
}
|
|
crate::api::rhttp::error::RhttpError::RhttpConnectionError(field0) => {
|
|
<i32>::sse_encode(5, serializer);
|
|
<String>::sse_encode(field0, serializer);
|
|
}
|
|
crate::api::rhttp::error::RhttpError::RhttpUnknownError(field0) => {
|
|
<i32>::sse_encode(6, serializer);
|
|
<String>::sse_encode(field0, serializer);
|
|
}
|
|
_ => {
|
|
unimplemented!("");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
impl SseEncode for crate::api::rhttp::client::StaticDnsSettings {
|
|
// 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, Vec<String>>>::sse_encode(self.overrides, serializer);
|
|
<Option<String>>::sse_encode(self.fallback, serializer);
|
|
}
|
|
}
|
|
|
|
impl SseEncode for crate::api::rhttp::client::TimeoutSettings {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
|
|
<Option<chrono::Duration>>::sse_encode(self.timeout, serializer);
|
|
<Option<chrono::Duration>>::sse_encode(self.connect_timeout, serializer);
|
|
<Option<chrono::Duration>>::sse_encode(self.keep_alive_timeout, serializer);
|
|
<Option<chrono::Duration>>::sse_encode(self.keep_alive_ping, serializer);
|
|
}
|
|
}
|
|
|
|
impl SseEncode for crate::api::rhttp::client::TlsSettings {
|
|
// 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.trust_root_certificates, serializer);
|
|
<Vec<Vec<u8>>>::sse_encode(self.trusted_root_certificates, serializer);
|
|
<bool>::sse_encode(self.verify_certificates, serializer);
|
|
<Option<crate::api::rhttp::client::ClientCertificate>>::sse_encode(
|
|
self.client_certificate,
|
|
serializer,
|
|
);
|
|
<Option<crate::api::rhttp::client::TlsVersion>>::sse_encode(
|
|
self.min_tls_version,
|
|
serializer,
|
|
);
|
|
<Option<crate::api::rhttp::client::TlsVersion>>::sse_encode(
|
|
self.max_tls_version,
|
|
serializer,
|
|
);
|
|
}
|
|
}
|
|
|
|
impl SseEncode for crate::api::rhttp::client::TlsVersion {
|
|
// 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::rhttp::client::TlsVersion::Tls1_2 => 0,
|
|
crate::api::rhttp::client::TlsVersion::Tls1_3 => 1,
|
|
_ => {
|
|
unimplemented!("");
|
|
}
|
|
},
|
|
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 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();
|
|
}
|
|
}
|
|
|
|
#[cfg(not(target_family = "wasm"))]
|
|
mod io {
|
|
// This file is automatically generated, so please do not edit it.
|
|
// @generated by `flutter_rust_bridge`@ 2.11.1.
|
|
|
|
// Section: imports
|
|
|
|
use super::*;
|
|
use crate::api::rhttp::client::*;
|
|
use crate::*;
|
|
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_mangayomi_rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerCancellationToken(
|
|
ptr: *const std::ffi::c_void,
|
|
) {
|
|
MoiArc::<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<CancellationToken>>::increment_strong_count(ptr as _);
|
|
}
|
|
|
|
#[unsafe(no_mangle)]
|
|
pub extern "C" fn frbgen_mangayomi_rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerCancellationToken(
|
|
ptr: *const std::ffi::c_void,
|
|
) {
|
|
MoiArc::<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<CancellationToken>>::decrement_strong_count(ptr as _);
|
|
}
|
|
|
|
#[unsafe(no_mangle)]
|
|
pub extern "C" fn frbgen_mangayomi_rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerDnsSettings(
|
|
ptr: *const std::ffi::c_void,
|
|
) {
|
|
MoiArc::<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<DnsSettings>>::increment_strong_count(ptr as _);
|
|
}
|
|
|
|
#[unsafe(no_mangle)]
|
|
pub extern "C" fn frbgen_mangayomi_rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerDnsSettings(
|
|
ptr: *const std::ffi::c_void,
|
|
) {
|
|
MoiArc::<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<DnsSettings>>::decrement_strong_count(ptr as _);
|
|
}
|
|
|
|
#[unsafe(no_mangle)]
|
|
pub extern "C" fn frbgen_mangayomi_rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerRequestClient(
|
|
ptr: *const std::ffi::c_void,
|
|
) {
|
|
MoiArc::<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RequestClient>>::increment_strong_count(ptr as _);
|
|
}
|
|
|
|
#[unsafe(no_mangle)]
|
|
pub extern "C" fn frbgen_mangayomi_rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerRequestClient(
|
|
ptr: *const std::ffi::c_void,
|
|
) {
|
|
MoiArc::<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RequestClient>>::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.11.1.
|
|
|
|
// Section: imports
|
|
|
|
use super::*;
|
|
use crate::api::rhttp::client::*;
|
|
use crate::*;
|
|
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_generatedRustAutoOpaqueInnerCancellationToken(
|
|
ptr: *const std::ffi::c_void,
|
|
) {
|
|
MoiArc::<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<CancellationToken>>::increment_strong_count(ptr as _);
|
|
}
|
|
|
|
#[wasm_bindgen]
|
|
pub fn rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerCancellationToken(
|
|
ptr: *const std::ffi::c_void,
|
|
) {
|
|
MoiArc::<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<CancellationToken>>::decrement_strong_count(ptr as _);
|
|
}
|
|
|
|
#[wasm_bindgen]
|
|
pub fn rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerDnsSettings(
|
|
ptr: *const std::ffi::c_void,
|
|
) {
|
|
MoiArc::<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<DnsSettings>>::increment_strong_count(ptr as _);
|
|
}
|
|
|
|
#[wasm_bindgen]
|
|
pub fn rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerDnsSettings(
|
|
ptr: *const std::ffi::c_void,
|
|
) {
|
|
MoiArc::<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<DnsSettings>>::decrement_strong_count(ptr as _);
|
|
}
|
|
|
|
#[wasm_bindgen]
|
|
pub fn rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerRequestClient(
|
|
ptr: *const std::ffi::c_void,
|
|
) {
|
|
MoiArc::<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RequestClient>>::increment_strong_count(ptr as _);
|
|
}
|
|
|
|
#[wasm_bindgen]
|
|
pub fn rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerRequestClient(
|
|
ptr: *const std::ffi::c_void,
|
|
) {
|
|
MoiArc::<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RequestClient>>::decrement_strong_count(ptr as _);
|
|
}
|
|
}
|
|
#[cfg(target_family = "wasm")]
|
|
pub use web::*;
|