2024-02-06 20:19:53 +08:00
|
|
|
// This file is automatically generated, so please do not edit it.
|
2024-04-16 19:29:19 +08:00
|
|
|
// Generated by `flutter_rust_bridge`@ 2.0.0-dev.32.
|
2024-02-06 20:19:53 +08:00
|
|
|
|
|
|
|
#![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
|
|
|
|
)]
|
|
|
|
|
|
|
|
// Section: imports
|
|
|
|
|
2024-04-16 22:34:50 +08:00
|
|
|
use crate::api::rs_process::*;
|
2024-02-06 20:19:53 +08:00
|
|
|
use flutter_rust_bridge::for_generated::byteorder::{NativeEndian, ReadBytesExt, WriteBytesExt};
|
|
|
|
use flutter_rust_bridge::for_generated::transform_result_dco;
|
|
|
|
use flutter_rust_bridge::{Handler, IntoIntoDart};
|
|
|
|
|
|
|
|
// Section: boilerplate
|
|
|
|
|
|
|
|
flutter_rust_bridge::frb_generated_boilerplate!(
|
2024-03-13 22:41:28 +08:00
|
|
|
default_stream_sink_codec = DcoCodec,
|
|
|
|
default_rust_opaque = RustOpaqueNom,
|
|
|
|
default_rust_auto_opaque = RustAutoOpaqueNom,
|
2024-02-06 20:19:53 +08:00
|
|
|
);
|
2024-04-16 19:29:19 +08:00
|
|
|
pub(crate) const FLUTTER_RUST_BRIDGE_CODEGEN_VERSION: &str = "2.0.0-dev.32";
|
2024-04-16 22:34:50 +08:00
|
|
|
pub(crate) const FLUTTER_RUST_BRIDGE_CODEGEN_CONTENT_HASH: i32 = 333909092;
|
2024-02-06 20:19:53 +08:00
|
|
|
|
|
|
|
// Section: executor
|
|
|
|
|
|
|
|
flutter_rust_bridge::frb_generated_default_handler!();
|
|
|
|
|
|
|
|
// Section: wire_funcs
|
|
|
|
|
2024-03-12 20:07:06 +08:00
|
|
|
fn wire_dns_lookup_ips_impl(
|
|
|
|
port_: flutter_rust_bridge::for_generated::MessagePort,
|
2024-03-13 22:41:28 +08:00
|
|
|
host: impl CstDecode<String>,
|
2024-03-12 20:07:06 +08:00
|
|
|
) {
|
2024-03-13 22:41:28 +08:00
|
|
|
FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
|
2024-03-12 20:07:06 +08:00
|
|
|
flutter_rust_bridge::for_generated::TaskInfo {
|
|
|
|
debug_name: "dns_lookup_ips",
|
|
|
|
port: Some(port_),
|
|
|
|
mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
|
|
|
|
},
|
|
|
|
move || {
|
2024-03-13 22:41:28 +08:00
|
|
|
let api_host = host.cst_decode();
|
2024-03-12 20:07:06 +08:00
|
|
|
move |context| async move {
|
2024-03-13 22:41:28 +08:00
|
|
|
transform_result_dco(
|
2024-03-12 20:07:06 +08:00
|
|
|
(move || async move { crate::api::http_api::dns_lookup_ips(api_host).await })()
|
|
|
|
.await,
|
|
|
|
)
|
|
|
|
}
|
|
|
|
},
|
|
|
|
)
|
|
|
|
}
|
2024-02-07 22:19:43 +08:00
|
|
|
fn wire_dns_lookup_txt_impl(
|
|
|
|
port_: flutter_rust_bridge::for_generated::MessagePort,
|
2024-03-13 22:41:28 +08:00
|
|
|
host: impl CstDecode<String>,
|
2024-02-07 22:19:43 +08:00
|
|
|
) {
|
2024-03-13 22:41:28 +08:00
|
|
|
FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
|
2024-02-07 22:19:43 +08:00
|
|
|
flutter_rust_bridge::for_generated::TaskInfo {
|
|
|
|
debug_name: "dns_lookup_txt",
|
|
|
|
port: Some(port_),
|
|
|
|
mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
|
|
|
|
},
|
|
|
|
move || {
|
2024-03-13 22:41:28 +08:00
|
|
|
let api_host = host.cst_decode();
|
2024-02-07 22:19:43 +08:00
|
|
|
move |context| async move {
|
2024-03-13 22:41:28 +08:00
|
|
|
transform_result_dco(
|
2024-02-15 21:24:39 +08:00
|
|
|
(move || async move { crate::api::http_api::dns_lookup_txt(api_host).await })()
|
|
|
|
.await,
|
2024-02-07 22:19:43 +08:00
|
|
|
)
|
|
|
|
}
|
|
|
|
},
|
|
|
|
)
|
|
|
|
}
|
2024-02-07 19:32:36 +08:00
|
|
|
fn wire_fetch_impl(
|
2024-02-07 00:20:06 +08:00
|
|
|
port_: flutter_rust_bridge::for_generated::MessagePort,
|
2024-03-13 22:41:28 +08:00
|
|
|
method: impl CstDecode<crate::api::http_api::MyMethod>,
|
|
|
|
url: impl CstDecode<String>,
|
|
|
|
headers: impl CstDecode<Option<std::collections::HashMap<String, String>>>,
|
|
|
|
input_data: impl CstDecode<Option<Vec<u8>>>,
|
|
|
|
with_ip_address: impl CstDecode<Option<String>>,
|
2024-02-07 00:20:06 +08:00
|
|
|
) {
|
2024-03-13 22:41:28 +08:00
|
|
|
FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
|
2024-02-07 00:20:06 +08:00
|
|
|
flutter_rust_bridge::for_generated::TaskInfo {
|
2024-02-07 19:32:36 +08:00
|
|
|
debug_name: "fetch",
|
2024-02-07 00:20:06 +08:00
|
|
|
port: Some(port_),
|
|
|
|
mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
|
|
|
|
},
|
|
|
|
move || {
|
2024-03-13 22:41:28 +08:00
|
|
|
let api_method = method.cst_decode();
|
|
|
|
let api_url = url.cst_decode();
|
|
|
|
let api_headers = headers.cst_decode();
|
|
|
|
let api_input_data = input_data.cst_decode();
|
|
|
|
let api_with_ip_address = with_ip_address.cst_decode();
|
2024-02-07 19:32:36 +08:00
|
|
|
move |context| async move {
|
2024-03-13 22:41:28 +08:00
|
|
|
transform_result_dco(
|
2024-02-07 19:32:36 +08:00
|
|
|
(move || async move {
|
2024-02-15 21:24:39 +08:00
|
|
|
crate::api::http_api::fetch(
|
|
|
|
api_method,
|
|
|
|
api_url,
|
|
|
|
api_headers,
|
|
|
|
api_input_data,
|
2024-03-12 20:07:06 +08:00
|
|
|
api_with_ip_address,
|
2024-02-07 19:32:36 +08:00
|
|
|
)
|
2024-02-15 21:24:39 +08:00
|
|
|
.await
|
2024-02-07 19:32:36 +08:00
|
|
|
})()
|
|
|
|
.await,
|
|
|
|
)
|
2024-02-07 00:20:06 +08:00
|
|
|
}
|
|
|
|
},
|
|
|
|
)
|
|
|
|
}
|
2024-02-07 19:32:36 +08:00
|
|
|
fn wire_set_default_header_impl(
|
2024-02-07 00:20:06 +08:00
|
|
|
port_: flutter_rust_bridge::for_generated::MessagePort,
|
2024-03-13 22:41:28 +08:00
|
|
|
headers: impl CstDecode<std::collections::HashMap<String, String>>,
|
2024-02-07 00:20:06 +08:00
|
|
|
) {
|
2024-03-13 22:41:28 +08:00
|
|
|
FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::<flutter_rust_bridge::for_generated::DcoCodec, _, _>(
|
2024-02-07 00:20:06 +08:00
|
|
|
flutter_rust_bridge::for_generated::TaskInfo {
|
2024-02-07 19:32:36 +08:00
|
|
|
debug_name: "set_default_header",
|
2024-02-07 00:20:06 +08:00
|
|
|
port: Some(port_),
|
|
|
|
mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
|
|
|
|
},
|
|
|
|
move || {
|
2024-03-13 22:41:28 +08:00
|
|
|
let api_headers = headers.cst_decode();
|
2024-02-07 19:32:36 +08:00
|
|
|
move |context| {
|
2024-03-13 22:41:28 +08:00
|
|
|
transform_result_dco((move || {
|
2024-02-07 19:32:36 +08:00
|
|
|
Result::<_, ()>::Ok(crate::api::http_api::set_default_header(api_headers))
|
|
|
|
})())
|
2024-02-07 00:20:06 +08:00
|
|
|
}
|
|
|
|
},
|
|
|
|
)
|
|
|
|
}
|
2024-04-16 22:34:50 +08:00
|
|
|
fn wire_RsProcess_get_pid_impl(
|
|
|
|
that: impl CstDecode<
|
|
|
|
RustOpaqueNom<flutter_rust_bridge::for_generated::rust_async::RwLock<RsProcess>>,
|
|
|
|
>,
|
|
|
|
) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
|
|
|
|
FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::DcoCodec, _>(
|
|
|
|
flutter_rust_bridge::for_generated::TaskInfo {
|
|
|
|
debug_name: "RsProcess_get_pid",
|
|
|
|
port: None,
|
|
|
|
mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
|
|
|
|
},
|
|
|
|
move || {
|
|
|
|
let api_that = that.cst_decode();
|
|
|
|
transform_result_dco((move || {
|
|
|
|
let api_that = api_that.rust_auto_opaque_decode_ref();
|
|
|
|
Result::<_, ()>::Ok(crate::api::rs_process::RsProcess::get_pid(&api_that))
|
|
|
|
})())
|
|
|
|
},
|
|
|
|
)
|
|
|
|
}
|
|
|
|
fn wire_RsProcess_new_impl() -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
|
|
|
|
FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::DcoCodec, _>(
|
|
|
|
flutter_rust_bridge::for_generated::TaskInfo {
|
|
|
|
debug_name: "RsProcess_new",
|
|
|
|
port: None,
|
|
|
|
mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
|
|
|
|
},
|
|
|
|
move || {
|
|
|
|
transform_result_dco((move || {
|
|
|
|
Result::<_, ()>::Ok(crate::api::rs_process::RsProcess::new())
|
|
|
|
})())
|
|
|
|
},
|
|
|
|
)
|
|
|
|
}
|
|
|
|
fn wire_RsProcess_start_impl(
|
2024-02-25 10:30:20 +08:00
|
|
|
port_: flutter_rust_bridge::for_generated::MessagePort,
|
2024-04-16 22:34:50 +08:00
|
|
|
that: impl CstDecode<
|
|
|
|
RustOpaqueNom<flutter_rust_bridge::for_generated::rust_async::RwLock<RsProcess>>,
|
|
|
|
>,
|
2024-03-13 22:41:28 +08:00
|
|
|
executable: impl CstDecode<String>,
|
|
|
|
arguments: impl CstDecode<Vec<String>>,
|
|
|
|
working_directory: impl CstDecode<String>,
|
2024-04-16 22:34:50 +08:00
|
|
|
stream_sink: impl CstDecode<
|
|
|
|
StreamSink<
|
|
|
|
crate::api::rs_process::RsProcessStreamData,
|
|
|
|
flutter_rust_bridge::for_generated::DcoCodec,
|
|
|
|
>,
|
|
|
|
>,
|
2024-02-25 10:30:20 +08:00
|
|
|
) {
|
2024-03-13 22:41:28 +08:00
|
|
|
FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
|
2024-02-25 10:30:20 +08:00
|
|
|
flutter_rust_bridge::for_generated::TaskInfo {
|
2024-04-16 22:34:50 +08:00
|
|
|
debug_name: "RsProcess_start",
|
2024-02-25 10:30:20 +08:00
|
|
|
port: Some(port_),
|
2024-04-11 19:52:13 +08:00
|
|
|
mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
|
2024-02-25 10:30:20 +08:00
|
|
|
},
|
|
|
|
move || {
|
2024-04-16 22:34:50 +08:00
|
|
|
let api_that = that.cst_decode();
|
2024-03-13 22:41:28 +08:00
|
|
|
let api_executable = executable.cst_decode();
|
|
|
|
let api_arguments = arguments.cst_decode();
|
|
|
|
let api_working_directory = working_directory.cst_decode();
|
2024-04-11 19:52:13 +08:00
|
|
|
let api_stream_sink = stream_sink.cst_decode();
|
2024-02-25 10:30:20 +08:00
|
|
|
move |context| async move {
|
2024-03-13 22:41:28 +08:00
|
|
|
transform_result_dco(
|
2024-02-25 10:30:20 +08:00
|
|
|
(move || async move {
|
2024-04-16 22:34:50 +08:00
|
|
|
let mut api_that = api_that.rust_auto_opaque_decode_ref_mut();
|
2024-02-25 10:30:20 +08:00
|
|
|
Result::<_, ()>::Ok(
|
2024-04-16 22:34:50 +08:00
|
|
|
crate::api::rs_process::RsProcess::start(
|
|
|
|
&mut api_that,
|
2024-02-25 10:30:20 +08:00
|
|
|
api_executable,
|
|
|
|
api_arguments,
|
|
|
|
api_working_directory,
|
2024-04-11 19:52:13 +08:00
|
|
|
api_stream_sink,
|
2024-02-25 10:30:20 +08:00
|
|
|
)
|
|
|
|
.await,
|
|
|
|
)
|
|
|
|
})()
|
|
|
|
.await,
|
|
|
|
)
|
|
|
|
}
|
|
|
|
},
|
|
|
|
)
|
|
|
|
}
|
2024-04-16 22:34:50 +08:00
|
|
|
fn wire_RsProcess_write_impl(
|
|
|
|
port_: flutter_rust_bridge::for_generated::MessagePort,
|
|
|
|
that: impl CstDecode<
|
|
|
|
RustOpaqueNom<flutter_rust_bridge::for_generated::rust_async::RwLock<RsProcess>>,
|
|
|
|
>,
|
|
|
|
data: impl CstDecode<String>,
|
|
|
|
) {
|
|
|
|
FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
|
|
|
|
flutter_rust_bridge::for_generated::TaskInfo {
|
|
|
|
debug_name: "RsProcess_write",
|
|
|
|
port: Some(port_),
|
|
|
|
mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
|
|
|
|
},
|
|
|
|
move || {
|
|
|
|
let api_that = that.cst_decode();
|
|
|
|
let api_data = data.cst_decode();
|
|
|
|
move |context| async move {
|
|
|
|
transform_result_dco(
|
|
|
|
(move || async move {
|
|
|
|
let mut api_that = api_that.rust_auto_opaque_decode_ref_mut();
|
|
|
|
Result::<_, ()>::Ok(
|
|
|
|
crate::api::rs_process::RsProcess::write(&mut api_that, api_data).await,
|
|
|
|
)
|
|
|
|
})()
|
|
|
|
.await,
|
|
|
|
)
|
|
|
|
}
|
|
|
|
},
|
|
|
|
)
|
|
|
|
}
|
2024-02-06 20:19:53 +08:00
|
|
|
|
|
|
|
// Section: dart2rust
|
|
|
|
|
2024-03-13 22:41:28 +08:00
|
|
|
impl CstDecode<i32> for i32 {
|
|
|
|
// Codec=Cst (C-struct based), see doc to use other codecs
|
|
|
|
fn cst_decode(self) -> i32 {
|
|
|
|
self
|
|
|
|
}
|
|
|
|
}
|
|
|
|
impl CstDecode<crate::http_package::MyHttpVersion> for i32 {
|
|
|
|
// Codec=Cst (C-struct based), see doc to use other codecs
|
|
|
|
fn cst_decode(self) -> crate::http_package::MyHttpVersion {
|
|
|
|
match self {
|
|
|
|
0 => crate::http_package::MyHttpVersion::HTTP_09,
|
|
|
|
1 => crate::http_package::MyHttpVersion::HTTP_10,
|
|
|
|
2 => crate::http_package::MyHttpVersion::HTTP_11,
|
|
|
|
3 => crate::http_package::MyHttpVersion::HTTP_2,
|
|
|
|
4 => crate::http_package::MyHttpVersion::HTTP_3,
|
|
|
|
5 => crate::http_package::MyHttpVersion::HTTP_UNKNOWN,
|
|
|
|
_ => unreachable!("Invalid variant for MyHttpVersion: {}", self),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
impl CstDecode<crate::api::http_api::MyMethod> for i32 {
|
|
|
|
// Codec=Cst (C-struct based), see doc to use other codecs
|
|
|
|
fn cst_decode(self) -> crate::api::http_api::MyMethod {
|
|
|
|
match self {
|
|
|
|
0 => crate::api::http_api::MyMethod::Options,
|
|
|
|
1 => crate::api::http_api::MyMethod::Gets,
|
|
|
|
2 => crate::api::http_api::MyMethod::Post,
|
|
|
|
3 => crate::api::http_api::MyMethod::Put,
|
|
|
|
4 => crate::api::http_api::MyMethod::Delete,
|
|
|
|
5 => crate::api::http_api::MyMethod::Head,
|
|
|
|
6 => crate::api::http_api::MyMethod::Trace,
|
|
|
|
7 => crate::api::http_api::MyMethod::Connect,
|
|
|
|
8 => crate::api::http_api::MyMethod::Patch,
|
|
|
|
_ => unreachable!("Invalid variant for MyMethod: {}", self),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2024-04-16 22:34:50 +08:00
|
|
|
impl CstDecode<crate::api::rs_process::RsProcessStreamDataType> for i32 {
|
|
|
|
// Codec=Cst (C-struct based), see doc to use other codecs
|
|
|
|
fn cst_decode(self) -> crate::api::rs_process::RsProcessStreamDataType {
|
|
|
|
match self {
|
|
|
|
0 => crate::api::rs_process::RsProcessStreamDataType::Output,
|
|
|
|
1 => crate::api::rs_process::RsProcessStreamDataType::Error,
|
|
|
|
2 => crate::api::rs_process::RsProcessStreamDataType::Exit,
|
|
|
|
_ => unreachable!("Invalid variant for RsProcessStreamDataType: {}", self),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2024-03-13 22:41:28 +08:00
|
|
|
impl CstDecode<u16> for u16 {
|
|
|
|
// Codec=Cst (C-struct based), see doc to use other codecs
|
|
|
|
fn cst_decode(self) -> u16 {
|
|
|
|
self
|
|
|
|
}
|
|
|
|
}
|
2024-04-16 22:34:50 +08:00
|
|
|
impl CstDecode<u32> for u32 {
|
|
|
|
// Codec=Cst (C-struct based), see doc to use other codecs
|
|
|
|
fn cst_decode(self) -> u32 {
|
|
|
|
self
|
|
|
|
}
|
|
|
|
}
|
2024-03-13 22:41:28 +08:00
|
|
|
impl CstDecode<u64> for u64 {
|
|
|
|
// Codec=Cst (C-struct based), see doc to use other codecs
|
|
|
|
fn cst_decode(self) -> u64 {
|
|
|
|
self
|
|
|
|
}
|
|
|
|
}
|
|
|
|
impl CstDecode<u8> for u8 {
|
|
|
|
// Codec=Cst (C-struct based), see doc to use other codecs
|
|
|
|
fn cst_decode(self) -> u8 {
|
|
|
|
self
|
|
|
|
}
|
|
|
|
}
|
2024-04-16 22:34:50 +08:00
|
|
|
impl CstDecode<usize> for usize {
|
|
|
|
// Codec=Cst (C-struct based), see doc to use other codecs
|
|
|
|
fn cst_decode(self) -> usize {
|
|
|
|
self
|
|
|
|
}
|
|
|
|
}
|
2024-02-15 21:24:39 +08:00
|
|
|
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 {
|
|
|
|
unreachable!("");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2024-04-16 22:34:50 +08:00
|
|
|
impl SseDecode for RsProcess {
|
|
|
|
// 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 = <RustOpaqueNom<
|
|
|
|
flutter_rust_bridge::for_generated::rust_async::RwLock<RsProcess>,
|
|
|
|
>>::sse_decode(deserializer);
|
|
|
|
return inner.rust_auto_opaque_decode_owned();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2024-02-07 00:20:06 +08:00
|
|
|
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();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2024-04-16 22:34:50 +08:00
|
|
|
impl SseDecode
|
|
|
|
for RustOpaqueNom<flutter_rust_bridge::for_generated::rust_async::RwLock<RsProcess>>
|
|
|
|
{
|
|
|
|
// 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 { decode_rust_opaque_nom(inner) };
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl SseDecode
|
|
|
|
for StreamSink<
|
|
|
|
crate::api::rs_process::RsProcessStreamData,
|
|
|
|
flutter_rust_bridge::for_generated::DcoCodec,
|
|
|
|
>
|
|
|
|
{
|
2024-04-11 19:52:13 +08:00
|
|
|
// 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);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2024-02-06 20:19:53 +08:00
|
|
|
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 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()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2024-02-07 22:19:43 +08:00
|
|
|
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_;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2024-02-06 20:19:53 +08:00
|
|
|
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_;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2024-02-07 00:20:06 +08:00
|
|
|
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_;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2024-03-10 20:28:24 +08:00
|
|
|
impl SseDecode for crate::http_package::MyHttpVersion {
|
|
|
|
// 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::http_package::MyHttpVersion::HTTP_09,
|
|
|
|
1 => crate::http_package::MyHttpVersion::HTTP_10,
|
|
|
|
2 => crate::http_package::MyHttpVersion::HTTP_11,
|
|
|
|
3 => crate::http_package::MyHttpVersion::HTTP_2,
|
|
|
|
4 => crate::http_package::MyHttpVersion::HTTP_3,
|
2024-03-12 20:07:06 +08:00
|
|
|
5 => crate::http_package::MyHttpVersion::HTTP_UNKNOWN,
|
2024-03-10 20:28:24 +08:00
|
|
|
_ => unreachable!("Invalid variant for MyHttpVersion: {}", inner),
|
|
|
|
};
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2024-02-07 19:32:36 +08:00
|
|
|
impl SseDecode for crate::api::http_api::MyMethod {
|
|
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
|
|
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
|
|
|
|
let mut inner = <i32>::sse_decode(deserializer);
|
|
|
|
return match inner {
|
|
|
|
0 => crate::api::http_api::MyMethod::Options,
|
|
|
|
1 => crate::api::http_api::MyMethod::Gets,
|
|
|
|
2 => crate::api::http_api::MyMethod::Post,
|
|
|
|
3 => crate::api::http_api::MyMethod::Put,
|
|
|
|
4 => crate::api::http_api::MyMethod::Delete,
|
|
|
|
5 => crate::api::http_api::MyMethod::Head,
|
|
|
|
6 => crate::api::http_api::MyMethod::Trace,
|
|
|
|
7 => crate::api::http_api::MyMethod::Connect,
|
|
|
|
8 => crate::api::http_api::MyMethod::Patch,
|
|
|
|
_ => unreachable!("Invalid variant for MyMethod: {}", inner),
|
|
|
|
};
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2024-02-07 00:20:06 +08:00
|
|
|
impl SseDecode for Option<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 {
|
|
|
|
if (<bool>::sse_decode(deserializer)) {
|
|
|
|
return Some(<std::collections::HashMap<String, String>>::sse_decode(
|
|
|
|
deserializer,
|
|
|
|
));
|
|
|
|
} else {
|
|
|
|
return None;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2024-03-12 20:07:06 +08:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2024-04-16 22:34:50 +08:00
|
|
|
impl SseDecode for Option<u32> {
|
|
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
|
|
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
|
|
|
|
if (<bool>::sse_decode(deserializer)) {
|
|
|
|
return Some(<u32>::sse_decode(deserializer));
|
|
|
|
} else {
|
|
|
|
return None;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2024-02-07 19:32:36 +08:00
|
|
|
impl SseDecode for Option<u64> {
|
|
|
|
// 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(<u64>::sse_decode(deserializer));
|
|
|
|
} else {
|
|
|
|
return None;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl SseDecode for Option<Vec<u8>> {
|
2024-02-07 00:20:06 +08:00
|
|
|
// 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)) {
|
2024-02-07 19:32:36 +08:00
|
|
|
return Some(<Vec<u8>>::sse_decode(deserializer));
|
2024-02-07 00:20:06 +08:00
|
|
|
} else {
|
|
|
|
return None;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2024-04-16 22:34:50 +08:00
|
|
|
impl SseDecode for crate::api::rs_process::RsProcessStreamData {
|
|
|
|
// 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_dataType =
|
|
|
|
<crate::api::rs_process::RsProcessStreamDataType>::sse_decode(deserializer);
|
|
|
|
let mut var_data = <String>::sse_decode(deserializer);
|
|
|
|
return crate::api::rs_process::RsProcessStreamData {
|
|
|
|
data_type: var_dataType,
|
|
|
|
data: var_data,
|
|
|
|
};
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl SseDecode for crate::api::rs_process::RsProcessStreamDataType {
|
|
|
|
// 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::rs_process::RsProcessStreamDataType::Output,
|
|
|
|
1 => crate::api::rs_process::RsProcessStreamDataType::Error,
|
|
|
|
2 => crate::api::rs_process::RsProcessStreamDataType::Exit,
|
|
|
|
_ => unreachable!("Invalid variant for RsProcessStreamDataType: {}", inner),
|
|
|
|
};
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2024-02-07 19:32:36 +08:00
|
|
|
impl SseDecode for crate::http_package::RustHttpResponse {
|
|
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
|
|
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
|
|
|
|
let mut var_statusCode = <u16>::sse_decode(deserializer);
|
2024-02-22 20:38:35 +08:00
|
|
|
let mut var_headers = <std::collections::HashMap<String, String>>::sse_decode(deserializer);
|
2024-02-07 19:32:36 +08:00
|
|
|
let mut var_url = <String>::sse_decode(deserializer);
|
|
|
|
let mut var_contentLength = <Option<u64>>::sse_decode(deserializer);
|
2024-03-10 20:28:24 +08:00
|
|
|
let mut var_version = <crate::http_package::MyHttpVersion>::sse_decode(deserializer);
|
2024-02-07 19:32:36 +08:00
|
|
|
let mut var_remoteAddr = <String>::sse_decode(deserializer);
|
|
|
|
let mut var_data = <Option<Vec<u8>>>::sse_decode(deserializer);
|
|
|
|
return crate::http_package::RustHttpResponse {
|
|
|
|
status_code: var_statusCode,
|
|
|
|
headers: var_headers,
|
|
|
|
url: var_url,
|
|
|
|
content_length: var_contentLength,
|
|
|
|
version: var_version,
|
|
|
|
remote_addr: var_remoteAddr,
|
|
|
|
data: var_data,
|
|
|
|
};
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
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()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2024-04-16 22:34:50 +08:00
|
|
|
impl SseDecode for u32 {
|
|
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
|
|
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
|
|
|
|
deserializer.cursor.read_u32::<NativeEndian>().unwrap()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2024-02-06 20:19:53 +08:00
|
|
|
impl SseDecode for u64 {
|
|
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
|
|
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
|
|
|
|
deserializer.cursor.read_u64::<NativeEndian>().unwrap()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl SseDecode for u8 {
|
|
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
|
|
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
|
|
|
|
deserializer.cursor.read_u8().unwrap()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl SseDecode for () {
|
|
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
|
|
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {}
|
|
|
|
}
|
|
|
|
|
2024-04-16 22:34:50 +08:00
|
|
|
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 _
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2024-02-06 20:19:53 +08:00
|
|
|
impl SseDecode for bool {
|
|
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
|
|
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
|
|
|
|
deserializer.cursor.read_u8().unwrap() != 0
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
fn pde_ffi_dispatcher_primary_impl(
|
|
|
|
func_id: i32,
|
|
|
|
port: flutter_rust_bridge::for_generated::MessagePort,
|
|
|
|
ptr: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
|
|
|
|
rust_vec_len: i32,
|
|
|
|
data_len: i32,
|
|
|
|
) {
|
|
|
|
// Codec=Pde (Serialization + dispatch), see doc to use other codecs
|
|
|
|
match func_id {
|
|
|
|
_ => 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 {
|
|
|
|
_ => unreachable!(),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Section: rust2dart
|
|
|
|
|
2024-04-16 22:34:50 +08:00
|
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
|
|
impl flutter_rust_bridge::IntoDart for FrbWrapper<RsProcess> {
|
|
|
|
fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
|
|
|
|
flutter_rust_bridge::for_generated::rust_auto_opaque_encode::<_, StdArc<_>>(self.0)
|
|
|
|
.into_dart()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for FrbWrapper<RsProcess> {}
|
|
|
|
|
|
|
|
impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<RsProcess>> for RsProcess {
|
|
|
|
fn into_into_dart(self) -> FrbWrapper<RsProcess> {
|
|
|
|
self.into()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2024-02-07 19:32:36 +08:00
|
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
2024-03-10 20:28:24 +08:00
|
|
|
impl flutter_rust_bridge::IntoDart for crate::http_package::MyHttpVersion {
|
2024-02-07 19:32:36 +08:00
|
|
|
fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
|
2024-03-10 20:28:24 +08:00
|
|
|
match self {
|
|
|
|
Self::HTTP_09 => 0.into_dart(),
|
|
|
|
Self::HTTP_10 => 1.into_dart(),
|
|
|
|
Self::HTTP_11 => 2.into_dart(),
|
|
|
|
Self::HTTP_2 => 3.into_dart(),
|
|
|
|
Self::HTTP_3 => 4.into_dart(),
|
2024-03-12 20:07:06 +08:00
|
|
|
Self::HTTP_UNKNOWN => 5.into_dart(),
|
2024-03-10 20:28:24 +08:00
|
|
|
}
|
2024-02-07 19:32:36 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
|
2024-03-10 20:28:24 +08:00
|
|
|
for crate::http_package::MyHttpVersion
|
2024-02-07 19:32:36 +08:00
|
|
|
{
|
|
|
|
}
|
2024-03-10 20:28:24 +08:00
|
|
|
impl flutter_rust_bridge::IntoIntoDart<crate::http_package::MyHttpVersion>
|
|
|
|
for crate::http_package::MyHttpVersion
|
2024-02-07 19:32:36 +08:00
|
|
|
{
|
2024-03-10 20:28:24 +08:00
|
|
|
fn into_into_dart(self) -> crate::http_package::MyHttpVersion {
|
|
|
|
self
|
2024-02-07 19:32:36 +08:00
|
|
|
}
|
|
|
|
}
|
2024-02-06 20:19:53 +08:00
|
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
2024-02-07 19:32:36 +08:00
|
|
|
impl flutter_rust_bridge::IntoDart for crate::api::http_api::MyMethod {
|
|
|
|
fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
|
|
|
|
match self {
|
|
|
|
Self::Options => 0.into_dart(),
|
|
|
|
Self::Gets => 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(),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
|
|
|
|
for crate::api::http_api::MyMethod
|
|
|
|
{
|
|
|
|
}
|
|
|
|
impl flutter_rust_bridge::IntoIntoDart<crate::api::http_api::MyMethod>
|
|
|
|
for crate::api::http_api::MyMethod
|
|
|
|
{
|
|
|
|
fn into_into_dart(self) -> crate::api::http_api::MyMethod {
|
|
|
|
self
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
2024-04-16 22:34:50 +08:00
|
|
|
impl flutter_rust_bridge::IntoDart for crate::api::rs_process::RsProcessStreamData {
|
|
|
|
fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
|
|
|
|
[
|
|
|
|
self.data_type.into_into_dart().into_dart(),
|
|
|
|
self.data.into_into_dart().into_dart(),
|
|
|
|
]
|
|
|
|
.into_dart()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
|
|
|
|
for crate::api::rs_process::RsProcessStreamData
|
|
|
|
{
|
|
|
|
}
|
|
|
|
impl flutter_rust_bridge::IntoIntoDart<crate::api::rs_process::RsProcessStreamData>
|
|
|
|
for crate::api::rs_process::RsProcessStreamData
|
|
|
|
{
|
|
|
|
fn into_into_dart(self) -> crate::api::rs_process::RsProcessStreamData {
|
|
|
|
self
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
|
|
impl flutter_rust_bridge::IntoDart for crate::api::rs_process::RsProcessStreamDataType {
|
|
|
|
fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
|
|
|
|
match self {
|
|
|
|
Self::Output => 0.into_dart(),
|
|
|
|
Self::Error => 1.into_dart(),
|
|
|
|
Self::Exit => 2.into_dart(),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
|
|
|
|
for crate::api::rs_process::RsProcessStreamDataType
|
|
|
|
{
|
|
|
|
}
|
|
|
|
impl flutter_rust_bridge::IntoIntoDart<crate::api::rs_process::RsProcessStreamDataType>
|
|
|
|
for crate::api::rs_process::RsProcessStreamDataType
|
|
|
|
{
|
|
|
|
fn into_into_dart(self) -> crate::api::rs_process::RsProcessStreamDataType {
|
|
|
|
self
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
2024-02-07 19:32:36 +08:00
|
|
|
impl flutter_rust_bridge::IntoDart for crate::http_package::RustHttpResponse {
|
|
|
|
fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
|
|
|
|
[
|
|
|
|
self.status_code.into_into_dart().into_dart(),
|
|
|
|
self.headers.into_into_dart().into_dart(),
|
|
|
|
self.url.into_into_dart().into_dart(),
|
|
|
|
self.content_length.into_into_dart().into_dart(),
|
|
|
|
self.version.into_into_dart().into_dart(),
|
|
|
|
self.remote_addr.into_into_dart().into_dart(),
|
|
|
|
self.data.into_into_dart().into_dart(),
|
|
|
|
]
|
|
|
|
.into_dart()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
|
|
|
|
for crate::http_package::RustHttpResponse
|
|
|
|
{
|
|
|
|
}
|
|
|
|
impl flutter_rust_bridge::IntoIntoDart<crate::http_package::RustHttpResponse>
|
|
|
|
for crate::http_package::RustHttpResponse
|
|
|
|
{
|
|
|
|
fn into_into_dart(self) -> crate::http_package::RustHttpResponse {
|
|
|
|
self
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2024-02-15 21:24:39 +08:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2024-04-16 22:34:50 +08:00
|
|
|
impl SseEncode for RsProcess {
|
|
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
|
|
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
|
|
|
|
<RustOpaqueNom<flutter_rust_bridge::for_generated::rust_async::RwLock<RsProcess>>>::sse_encode(flutter_rust_bridge::for_generated::rust_auto_opaque_encode::<_, StdArc<_>>(self), serializer);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2024-02-07 00:20:06 +08:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2024-04-16 22:34:50 +08:00
|
|
|
impl SseEncode
|
|
|
|
for RustOpaqueNom<flutter_rust_bridge::for_generated::rust_async::RwLock<RsProcess>>
|
|
|
|
{
|
|
|
|
// 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<
|
|
|
|
crate::api::rs_process::RsProcessStreamData,
|
|
|
|
flutter_rust_bridge::for_generated::DcoCodec,
|
|
|
|
>
|
|
|
|
{
|
2024-04-11 19:52:13 +08:00
|
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
|
|
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
|
|
|
|
unimplemented!("")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2024-02-06 20:19:53 +08:00
|
|
|
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 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();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2024-02-07 22:19:43 +08:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2024-02-06 20:19:53 +08:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2024-02-07 00:20:06 +08:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2024-03-10 20:28:24 +08:00
|
|
|
impl SseEncode for crate::http_package::MyHttpVersion {
|
|
|
|
// 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::http_package::MyHttpVersion::HTTP_09 => 0,
|
|
|
|
crate::http_package::MyHttpVersion::HTTP_10 => 1,
|
|
|
|
crate::http_package::MyHttpVersion::HTTP_11 => 2,
|
|
|
|
crate::http_package::MyHttpVersion::HTTP_2 => 3,
|
|
|
|
crate::http_package::MyHttpVersion::HTTP_3 => 4,
|
2024-03-12 20:07:06 +08:00
|
|
|
crate::http_package::MyHttpVersion::HTTP_UNKNOWN => 5,
|
2024-03-10 20:28:24 +08:00
|
|
|
_ => {
|
|
|
|
unimplemented!("");
|
|
|
|
}
|
|
|
|
},
|
|
|
|
serializer,
|
|
|
|
);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2024-02-07 19:32:36 +08:00
|
|
|
impl SseEncode for crate::api::http_api::MyMethod {
|
|
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
|
|
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
|
|
|
|
<i32>::sse_encode(
|
|
|
|
match self {
|
|
|
|
crate::api::http_api::MyMethod::Options => 0,
|
|
|
|
crate::api::http_api::MyMethod::Gets => 1,
|
|
|
|
crate::api::http_api::MyMethod::Post => 2,
|
|
|
|
crate::api::http_api::MyMethod::Put => 3,
|
|
|
|
crate::api::http_api::MyMethod::Delete => 4,
|
|
|
|
crate::api::http_api::MyMethod::Head => 5,
|
|
|
|
crate::api::http_api::MyMethod::Trace => 6,
|
|
|
|
crate::api::http_api::MyMethod::Connect => 7,
|
|
|
|
crate::api::http_api::MyMethod::Patch => 8,
|
|
|
|
_ => {
|
|
|
|
unimplemented!("");
|
|
|
|
}
|
|
|
|
},
|
|
|
|
serializer,
|
|
|
|
);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2024-02-07 00:20:06 +08:00
|
|
|
impl SseEncode for Option<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) {
|
|
|
|
<bool>::sse_encode(self.is_some(), serializer);
|
|
|
|
if let Some(value) = self {
|
|
|
|
<std::collections::HashMap<String, String>>::sse_encode(value, serializer);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2024-03-12 20:07:06 +08:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2024-04-16 22:34:50 +08:00
|
|
|
impl SseEncode for Option<u32> {
|
|
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
|
|
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
|
|
|
|
<bool>::sse_encode(self.is_some(), serializer);
|
|
|
|
if let Some(value) = self {
|
|
|
|
<u32>::sse_encode(value, serializer);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2024-02-07 19:32:36 +08:00
|
|
|
impl SseEncode for Option<u64> {
|
|
|
|
// 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 {
|
|
|
|
<u64>::sse_encode(value, serializer);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl SseEncode for Option<Vec<u8>> {
|
2024-02-07 00:20:06 +08:00
|
|
|
// 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 {
|
2024-02-07 19:32:36 +08:00
|
|
|
<Vec<u8>>::sse_encode(value, serializer);
|
2024-02-07 00:20:06 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2024-04-16 22:34:50 +08:00
|
|
|
impl SseEncode for crate::api::rs_process::RsProcessStreamData {
|
|
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
|
|
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
|
|
|
|
<crate::api::rs_process::RsProcessStreamDataType>::sse_encode(self.data_type, serializer);
|
|
|
|
<String>::sse_encode(self.data, serializer);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl SseEncode for crate::api::rs_process::RsProcessStreamDataType {
|
|
|
|
// 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::rs_process::RsProcessStreamDataType::Output => 0,
|
|
|
|
crate::api::rs_process::RsProcessStreamDataType::Error => 1,
|
|
|
|
crate::api::rs_process::RsProcessStreamDataType::Exit => 2,
|
|
|
|
_ => {
|
|
|
|
unimplemented!("");
|
|
|
|
}
|
|
|
|
},
|
|
|
|
serializer,
|
|
|
|
);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2024-02-07 19:32:36 +08:00
|
|
|
impl SseEncode for crate::http_package::RustHttpResponse {
|
|
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
|
|
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
|
|
|
|
<u16>::sse_encode(self.status_code, serializer);
|
|
|
|
<std::collections::HashMap<String, String>>::sse_encode(self.headers, serializer);
|
|
|
|
<String>::sse_encode(self.url, serializer);
|
|
|
|
<Option<u64>>::sse_encode(self.content_length, serializer);
|
2024-03-10 20:28:24 +08:00
|
|
|
<crate::http_package::MyHttpVersion>::sse_encode(self.version, serializer);
|
2024-02-07 19:32:36 +08:00
|
|
|
<String>::sse_encode(self.remote_addr, serializer);
|
|
|
|
<Option<Vec<u8>>>::sse_encode(self.data, 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();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2024-04-16 22:34:50 +08:00
|
|
|
impl SseEncode for u32 {
|
|
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
|
|
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
|
|
|
|
serializer.cursor.write_u32::<NativeEndian>(self).unwrap();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2024-02-06 20:19:53 +08:00
|
|
|
impl SseEncode for u64 {
|
|
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
|
|
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
|
|
|
|
serializer.cursor.write_u64::<NativeEndian>(self).unwrap();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl SseEncode for u8 {
|
|
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
|
|
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
|
|
|
|
serializer.cursor.write_u8(self).unwrap();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl SseEncode for () {
|
|
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
|
|
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {}
|
|
|
|
}
|
|
|
|
|
2024-04-16 22:34:50 +08:00
|
|
|
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();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2024-02-06 20:19:53 +08:00
|
|
|
impl SseEncode for bool {
|
|
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
|
|
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
|
|
|
|
serializer.cursor.write_u8(self as _).unwrap();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[cfg(not(target_family = "wasm"))]
|
|
|
|
#[path = "frb_generated.io.rs"]
|
|
|
|
mod io;
|
|
|
|
#[cfg(not(target_family = "wasm"))]
|
|
|
|
pub use io::*;
|