app/rust/src/frb_generated.rs

1597 lines
59 KiB
Rust
Raw Permalink Normal View History

2024-02-06 20:19:53 +08:00
// This file is automatically generated, so please do not edit it.
// @generated by `flutter_rust_bridge`@ 2.6.0.
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,
2024-05-22 20:05:50 +08:00
clippy::match_single_binding,
clippy::clone_on_copy,
2024-06-17 19:16:09 +08:00
clippy::let_unit_value,
clippy::deref_addrof,
clippy::explicit_auto_deref,
clippy::borrow_deref_ref,
clippy::needless_borrow
2024-02-06 20:19:53 +08:00
)]
// Section: imports
use flutter_rust_bridge::for_generated::byteorder::{NativeEndian, ReadBytesExt, WriteBytesExt};
2024-06-17 19:16:09 +08:00
use flutter_rust_bridge::for_generated::{transform_result_dco, Lifetimeable, Lockable};
2024-02-06 20:19:53 +08:00
use flutter_rust_bridge::{Handler, IntoIntoDart};
// Section: boilerplate
flutter_rust_bridge::frb_generated_boilerplate!(
default_stream_sink_codec = DcoCodec,
default_rust_opaque = RustOpaqueNom,
default_rust_auto_opaque = RustAutoOpaqueNom,
2024-02-06 20:19:53 +08:00
);
pub(crate) const FLUTTER_RUST_BRIDGE_CODEGEN_VERSION: &str = "2.6.0";
2024-11-29 18:25:42 +08:00
pub(crate) const FLUTTER_RUST_BRIDGE_CODEGEN_CONTENT_HASH: i32 = 1832496273;
2024-02-06 20:19:53 +08:00
// Section: executor
flutter_rust_bridge::frb_generated_default_handler!();
// Section: wire_funcs
fn wire__crate__api__http_api__dns_lookup_ips_impl(
2024-05-01 13:48:37 +08:00
port_: flutter_rust_bridge::for_generated::MessagePort,
host: impl CstDecode<String>,
2024-05-01 13:48:37 +08:00
) {
FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
flutter_rust_bridge::for_generated::TaskInfo {
debug_name: "dns_lookup_ips",
2024-05-01 13:48:37 +08:00
port: Some(port_),
mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
},
move || {
let api_host = host.cst_decode();
2024-05-01 13:48:37 +08:00
move |context| async move {
2024-06-17 19:16:09 +08:00
transform_result_dco::<_, _, flutter_rust_bridge::for_generated::anyhow::Error>(
2024-05-01 13:48:37 +08:00
(move || async move {
let output_ok = crate::api::http_api::dns_lookup_ips(api_host).await?;
2024-06-17 19:16:09 +08:00
Ok(output_ok)
2024-05-01 13:48:37 +08:00
})()
.await,
)
}
},
)
}
fn wire__crate__api__http_api__dns_lookup_txt_impl(
2024-05-01 13:48:37 +08:00
port_: flutter_rust_bridge::for_generated::MessagePort,
host: impl CstDecode<String>,
2024-05-01 13:48:37 +08:00
) {
FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
flutter_rust_bridge::for_generated::TaskInfo {
debug_name: "dns_lookup_txt",
2024-05-01 13:48:37 +08:00
port: Some(port_),
mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
},
move || {
let api_host = host.cst_decode();
2024-05-01 13:48:37 +08:00
move |context| async move {
2024-06-17 19:16:09 +08:00
transform_result_dco::<_, _, flutter_rust_bridge::for_generated::anyhow::Error>(
2024-05-01 13:48:37 +08:00
(move || async move {
let output_ok = crate::api::http_api::dns_lookup_txt(api_host).await?;
2024-06-17 19:16:09 +08:00
Ok(output_ok)
2024-05-01 13:48:37 +08:00
})()
.await,
)
}
},
)
}
fn wire__crate__api__http_api__fetch_impl(
2024-03-12 20:07:06 +08:00
port_: flutter_rust_bridge::for_generated::MessagePort,
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>>,
with_custom_dns: impl CstDecode<Option<bool>>,
2024-03-12 20:07:06 +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: "fetch",
2024-03-12 20:07:06 +08:00
port: Some(port_),
mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
},
move || {
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();
let api_with_custom_dns = with_custom_dns.cst_decode();
2024-03-12 20:07:06 +08:00
move |context| async move {
2024-06-17 19:16:09 +08:00
transform_result_dco::<_, _, flutter_rust_bridge::for_generated::anyhow::Error>(
(move || async move {
let output_ok = crate::api::http_api::fetch(
api_method,
api_url,
api_headers,
api_input_data,
api_with_ip_address,
api_with_custom_dns,
)
.await?;
2024-06-17 19:16:09 +08:00
Ok(output_ok)
})()
.await,
2024-03-12 20:07:06 +08:00
)
}
},
)
}
fn wire__crate__api__asar_api__get_rsi_launcher_asar_data_impl(
2024-02-07 22:19:43 +08:00
port_: flutter_rust_bridge::for_generated::MessagePort,
asar_path: impl CstDecode<String>,
2024-02-07 22:19:43 +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: "get_rsi_launcher_asar_data",
2024-02-07 22:19:43 +08:00
port: Some(port_),
mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
},
move || {
let api_asar_path = asar_path.cst_decode();
2024-02-07 22:19:43 +08:00
move |context| async move {
2024-06-17 19:16:09 +08:00
transform_result_dco::<_, _, flutter_rust_bridge::for_generated::anyhow::Error>(
(move || async move {
let output_ok =
crate::api::asar_api::get_rsi_launcher_asar_data(&api_asar_path)
.await?;
2024-06-17 19:16:09 +08:00
Ok(output_ok)
})()
.await,
2024-02-07 22:19:43 +08:00
)
}
},
)
}
fn wire__crate__api__asar_api__rsi_launcher_asar_data_write_main_js_impl(
2024-02-07 00:20:06 +08:00
port_: flutter_rust_bridge::for_generated::MessagePort,
that: impl CstDecode<crate::api::asar_api::RsiLauncherAsarData>,
content: impl CstDecode<Vec<u8>>,
2024-02-07 00:20:06 +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 {
debug_name: "rsi_launcher_asar_data_write_main_js",
2024-02-07 00:20:06 +08:00
port: Some(port_),
mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
},
move || {
let api_that = that.cst_decode();
let api_content = content.cst_decode();
2024-02-07 19:32:36 +08:00
move |context| async move {
2024-06-17 19:16:09 +08:00
transform_result_dco::<_, _, flutter_rust_bridge::for_generated::anyhow::Error>(
2024-02-07 19:32:36 +08:00
(move || async move {
let output_ok = crate::api::asar_api::RsiLauncherAsarData::write_main_js(
&api_that,
api_content,
2024-02-07 19:32:36 +08:00
)
2024-06-17 19:16:09 +08:00
.await?;
Ok(output_ok)
2024-02-07 19:32:36 +08:00
})()
.await,
)
2024-02-07 00:20:06 +08:00
}
},
)
}
fn wire__crate__api__win32_api__send_notify_impl(
port_: flutter_rust_bridge::for_generated::MessagePort,
summary: impl CstDecode<Option<String>>,
body: impl CstDecode<Option<String>>,
app_name: impl CstDecode<Option<String>>,
app_id: impl CstDecode<Option<String>>,
) {
FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::<flutter_rust_bridge::for_generated::DcoCodec, _, _>(
flutter_rust_bridge::for_generated::TaskInfo {
debug_name: "send_notify",
port: Some(port_),
mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
},
move || {
let api_summary = summary.cst_decode();
let api_body = body.cst_decode();
let api_app_name = app_name.cst_decode();
let api_app_id = app_id.cst_decode();
move |context| {
transform_result_dco::<_, _, flutter_rust_bridge::for_generated::anyhow::Error>(
(move || {
let output_ok = crate::api::win32_api::send_notify(
api_summary,
api_body,
api_app_name,
api_app_id,
)?;
Ok(output_ok)
})(),
)
}
},
)
}
2024-05-22 20:05:50 +08:00
fn wire__crate__api__http_api__set_default_header_impl(
2024-02-07 00:20:06 +08:00
port_: flutter_rust_bridge::for_generated::MessagePort,
headers: impl CstDecode<std::collections::HashMap<String, String>>,
2024-02-07 00:20:06 +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 || {
let api_headers = headers.cst_decode();
2024-02-07 19:32:36 +08:00
move |context| {
2024-06-17 19:16:09 +08:00
transform_result_dco::<_, _, ()>((move || {
let output_ok = Result::<_, ()>::Ok({
2024-06-11 19:55:35 +08:00
crate::api::http_api::set_default_header(api_headers);
2024-06-17 19:16:09 +08:00
})?;
Ok(output_ok)
2024-02-07 19:32:36 +08:00
})())
2024-02-07 00:20:06 +08:00
}
},
)
}
fn wire__crate__api__win32_api__set_foreground_window_impl(
port_: flutter_rust_bridge::for_generated::MessagePort,
window_name: impl CstDecode<String>,
) {
FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::<flutter_rust_bridge::for_generated::DcoCodec, _, _>(
flutter_rust_bridge::for_generated::TaskInfo {
debug_name: "set_foreground_window",
port: Some(port_),
mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
},
move || {
let api_window_name = window_name.cst_decode();
move |context| {
transform_result_dco::<_, _, flutter_rust_bridge::for_generated::anyhow::Error>(
(move || {
let output_ok =
crate::api::win32_api::set_foreground_window(&api_window_name)?;
Ok(output_ok)
})(),
)
}
},
)
}
2024-05-22 20:05:50 +08:00
fn wire__crate__api__rs_process__start_impl(
port_: flutter_rust_bridge::for_generated::MessagePort,
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,
>,
>,
) {
FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
flutter_rust_bridge::for_generated::TaskInfo {
2024-04-17 21:40:08 +08:00
debug_name: "start",
port: Some(port_),
mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
},
move || {
let api_executable = executable.cst_decode();
let api_arguments = arguments.cst_decode();
let api_working_directory = working_directory.cst_decode();
let api_stream_sink = stream_sink.cst_decode();
move |context| async move {
2024-06-17 19:16:09 +08:00
transform_result_dco::<_, _, ()>(
(move || async move {
2024-06-17 19:16:09 +08:00
let output_ok = Result::<_, ()>::Ok({
2024-04-17 21:40:08 +08:00
crate::api::rs_process::start(
&api_executable,
api_arguments,
&api_working_directory,
api_stream_sink,
)
2024-06-11 19:55:35 +08:00
.await;
2024-06-17 19:16:09 +08:00
})?;
Ok(output_ok)
})()
.await,
)
}
},
)
}
2024-05-22 20:05:50 +08:00
fn wire__crate__api__rs_process__write_impl(
2024-04-16 22:34:50 +08:00
port_: flutter_rust_bridge::for_generated::MessagePort,
2024-04-17 21:40:08 +08:00
rs_pid: impl CstDecode<u32>,
2024-04-16 22:34:50 +08:00
data: impl CstDecode<String>,
) {
FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
flutter_rust_bridge::for_generated::TaskInfo {
2024-04-17 21:40:08 +08:00
debug_name: "write",
2024-04-16 22:34:50 +08:00
port: Some(port_),
mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
},
move || {
2024-04-17 21:40:08 +08:00
let api_rs_pid = rs_pid.cst_decode();
2024-04-16 22:34:50 +08:00
let api_data = data.cst_decode();
move |context| async move {
2024-06-17 19:16:09 +08:00
transform_result_dco::<_, _, ()>(
2024-04-16 22:34:50 +08:00
(move || async move {
2024-06-17 19:16:09 +08:00
let output_ok = Result::<_, ()>::Ok({
2024-06-11 19:55:35 +08:00
crate::api::rs_process::write(&api_rs_pid, api_data).await;
2024-06-17 19:16:09 +08:00
})?;
Ok(output_ok)
2024-04-16 22:34:50 +08:00
})()
.await,
)
}
},
)
}
2024-02-06 20:19:53 +08:00
// Section: dart2rust
impl CstDecode<bool> for bool {
// Codec=Cst (C-struct based), see doc to use other codecs
fn cst_decode(self) -> bool {
self
}
}
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),
}
}
}
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
}
}
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-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 {
2024-05-22 20:05:50 +08:00
let mut inner = <String>::sse_decode(deserializer);
return flutter_rust_bridge::for_generated::anyhow::anyhow!("{}", inner);
2024-02-15 21:24:39 +08:00
}
}
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 StreamSink<
crate::api::rs_process::RsProcessStreamData,
flutter_rust_bridge::for_generated::DcoCodec,
>
{
// 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 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
}
}
2024-02-06 20:19:53 +08:00
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_;
}
}
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,
_ => 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;
}
}
}
impl SseDecode for Option<bool> {
// 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(<bool>::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);
2024-04-17 21:40:08 +08:00
let mut var_rsPid = <u32>::sse_decode(deserializer);
2024-04-16 22:34:50 +08:00
return crate::api::rs_process::RsProcessStreamData {
data_type: var_dataType,
data: var_data,
2024-04-17 21:40:08 +08:00
rs_pid: var_rsPid,
2024-04-16 22:34:50 +08:00
};
}
}
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-05-01 13:48:37 +08:00
impl SseDecode for crate::api::asar_api::RsiLauncherAsarData {
// 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_asarPath = <String>::sse_decode(deserializer);
let mut var_mainJsPath = <String>::sse_decode(deserializer);
let mut var_mainJsContent = <Vec<u8>>::sse_decode(deserializer);
return crate::api::asar_api::RsiLauncherAsarData {
asar_path: var_asarPath,
main_js_path: var_mainJsPath,
main_js_content: var_mainJsContent,
};
}
}
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);
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 {}
}
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-02-07 19:32:36 +08:00
// Codec=Dco (DartCObject based), see doc to use other codecs
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 {
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-06-11 19:55:35 +08:00
_ => unreachable!(),
}
2024-02-07 19:32:36 +08:00
}
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
for crate::http_package::MyHttpVersion
2024-02-07 19:32:36 +08:00
{
}
impl flutter_rust_bridge::IntoIntoDart<crate::http_package::MyHttpVersion>
for crate::http_package::MyHttpVersion
2024-02-07 19:32:36 +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(),
2024-06-11 19:55:35 +08:00
_ => unreachable!(),
2024-02-07 19:32:36 +08:00
}
}
}
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(),
2024-04-17 21:40:08 +08:00
self.rs_pid.into_into_dart().into_dart(),
2024-04-16 22:34:50 +08:00
]
.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(),
2024-06-11 19:55:35 +08:00
_ => unreachable!(),
2024-04-16 22:34:50 +08:00
}
}
}
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-05-01 13:48:37 +08:00
impl flutter_rust_bridge::IntoDart for crate::api::asar_api::RsiLauncherAsarData {
fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
[
self.asar_path.into_into_dart().into_dart(),
self.main_js_path.into_into_dart().into_dart(),
self.main_js_content.into_into_dart().into_dart(),
]
.into_dart()
}
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
for crate::api::asar_api::RsiLauncherAsarData
{
}
impl flutter_rust_bridge::IntoIntoDart<crate::api::asar_api::RsiLauncherAsarData>
for crate::api::asar_api::RsiLauncherAsarData
{
fn into_into_dart(self) -> crate::api::asar_api::RsiLauncherAsarData {
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-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 StreamSink<
crate::api::rs_process::RsProcessStreamData,
flutter_rust_bridge::for_generated::DcoCodec,
>
{
// 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 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();
}
}
2024-02-06 20:19:53 +08:00
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);
}
}
}
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,
_ => {
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);
}
}
}
impl SseEncode for Option<bool> {
// 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 {
<bool>::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);
2024-04-17 21:40:08 +08:00
<u32>::sse_encode(self.rs_pid, serializer);
2024-04-16 22:34:50 +08:00
}
}
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-05-01 13:48:37 +08:00
impl SseEncode for crate::api::asar_api::RsiLauncherAsarData {
// 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.asar_path, serializer);
<String>::sse_encode(self.main_js_path, serializer);
<Vec<u8>>::sse_encode(self.main_js_content, 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);
<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) {}
}
#[cfg(not(target_family = "wasm"))]
2024-07-07 16:50:23 +08:00
mod io {
// This file is automatically generated, so please do not edit it.
// @generated by `flutter_rust_bridge`@ 2.6.0.
2024-07-07 16:50:23 +08:00
// Section: imports
use super::*;
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!();
// Section: dart2rust
impl CstDecode<flutter_rust_bridge::for_generated::anyhow::Error>
for *mut wire_cst_list_prim_u_8_strict
{
// Codec=Cst (C-struct based), see doc to use other codecs
fn cst_decode(self) -> flutter_rust_bridge::for_generated::anyhow::Error {
unimplemented!()
}
}
impl CstDecode<std::collections::HashMap<String, String>>
for *mut wire_cst_list_record_string_string
{
// Codec=Cst (C-struct based), see doc to use other codecs
fn cst_decode(self) -> std::collections::HashMap<String, String> {
let vec: Vec<(String, String)> = self.cst_decode();
vec.into_iter().collect()
}
}
impl
CstDecode<
StreamSink<
crate::api::rs_process::RsProcessStreamData,
flutter_rust_bridge::for_generated::DcoCodec,
>,
> for *mut wire_cst_list_prim_u_8_strict
{
// Codec=Cst (C-struct based), see doc to use other codecs
fn cst_decode(
self,
) -> StreamSink<
crate::api::rs_process::RsProcessStreamData,
flutter_rust_bridge::for_generated::DcoCodec,
> {
let raw: String = self.cst_decode();
StreamSink::deserialize(raw)
}
}
impl CstDecode<String> for *mut wire_cst_list_prim_u_8_strict {
// Codec=Cst (C-struct based), see doc to use other codecs
fn cst_decode(self) -> String {
let vec: Vec<u8> = self.cst_decode();
String::from_utf8(vec).unwrap()
}
}
impl CstDecode<bool> for *mut bool {
// Codec=Cst (C-struct based), see doc to use other codecs
fn cst_decode(self) -> bool {
unsafe { *flutter_rust_bridge::for_generated::box_from_leak_ptr(self) }
}
}
2024-07-07 16:50:23 +08:00
impl CstDecode<crate::api::asar_api::RsiLauncherAsarData> for *mut wire_cst_rsi_launcher_asar_data {
// Codec=Cst (C-struct based), see doc to use other codecs
fn cst_decode(self) -> crate::api::asar_api::RsiLauncherAsarData {
let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
CstDecode::<crate::api::asar_api::RsiLauncherAsarData>::cst_decode(*wrap).into()
}
}
impl CstDecode<u64> for *mut u64 {
// Codec=Cst (C-struct based), see doc to use other codecs
fn cst_decode(self) -> u64 {
unsafe { *flutter_rust_bridge::for_generated::box_from_leak_ptr(self) }
}
}
impl CstDecode<Vec<String>> for *mut wire_cst_list_String {
// Codec=Cst (C-struct based), see doc to use other codecs
fn cst_decode(self) -> Vec<String> {
let vec = unsafe {
let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
};
vec.into_iter().map(CstDecode::cst_decode).collect()
}
}
impl CstDecode<Vec<u8>> for *mut wire_cst_list_prim_u_8_loose {
// Codec=Cst (C-struct based), see doc to use other codecs
fn cst_decode(self) -> Vec<u8> {
unsafe {
let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
}
}
}
impl CstDecode<Vec<u8>> for *mut wire_cst_list_prim_u_8_strict {
// Codec=Cst (C-struct based), see doc to use other codecs
fn cst_decode(self) -> Vec<u8> {
unsafe {
let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
}
}
}
impl CstDecode<Vec<(String, String)>> for *mut wire_cst_list_record_string_string {
// Codec=Cst (C-struct based), see doc to use other codecs
fn cst_decode(self) -> Vec<(String, String)> {
let vec = unsafe {
let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
};
vec.into_iter().map(CstDecode::cst_decode).collect()
}
}
impl CstDecode<(String, String)> for wire_cst_record_string_string {
// Codec=Cst (C-struct based), see doc to use other codecs
fn cst_decode(self) -> (String, String) {
(self.field0.cst_decode(), self.field1.cst_decode())
}
}
impl CstDecode<crate::api::rs_process::RsProcessStreamData> for wire_cst_rs_process_stream_data {
// Codec=Cst (C-struct based), see doc to use other codecs
fn cst_decode(self) -> crate::api::rs_process::RsProcessStreamData {
crate::api::rs_process::RsProcessStreamData {
data_type: self.data_type.cst_decode(),
data: self.data.cst_decode(),
rs_pid: self.rs_pid.cst_decode(),
}
}
}
impl CstDecode<crate::api::asar_api::RsiLauncherAsarData> for wire_cst_rsi_launcher_asar_data {
// Codec=Cst (C-struct based), see doc to use other codecs
fn cst_decode(self) -> crate::api::asar_api::RsiLauncherAsarData {
crate::api::asar_api::RsiLauncherAsarData {
asar_path: self.asar_path.cst_decode(),
main_js_path: self.main_js_path.cst_decode(),
main_js_content: self.main_js_content.cst_decode(),
}
}
}
impl CstDecode<crate::http_package::RustHttpResponse> for wire_cst_rust_http_response {
// Codec=Cst (C-struct based), see doc to use other codecs
fn cst_decode(self) -> crate::http_package::RustHttpResponse {
crate::http_package::RustHttpResponse {
status_code: self.status_code.cst_decode(),
headers: self.headers.cst_decode(),
url: self.url.cst_decode(),
content_length: self.content_length.cst_decode(),
version: self.version.cst_decode(),
remote_addr: self.remote_addr.cst_decode(),
data: self.data.cst_decode(),
}
}
}
impl NewWithNullPtr for wire_cst_record_string_string {
fn new_with_null_ptr() -> Self {
Self {
field0: core::ptr::null_mut(),
field1: core::ptr::null_mut(),
}
}
}
impl Default for wire_cst_record_string_string {
fn default() -> Self {
Self::new_with_null_ptr()
}
}
impl NewWithNullPtr for wire_cst_rs_process_stream_data {
fn new_with_null_ptr() -> Self {
Self {
data_type: Default::default(),
data: core::ptr::null_mut(),
rs_pid: Default::default(),
}
}
}
impl Default for wire_cst_rs_process_stream_data {
fn default() -> Self {
Self::new_with_null_ptr()
}
}
impl NewWithNullPtr for wire_cst_rsi_launcher_asar_data {
fn new_with_null_ptr() -> Self {
Self {
asar_path: core::ptr::null_mut(),
main_js_path: core::ptr::null_mut(),
main_js_content: core::ptr::null_mut(),
}
}
}
impl Default for wire_cst_rsi_launcher_asar_data {
fn default() -> Self {
Self::new_with_null_ptr()
}
}
impl NewWithNullPtr for wire_cst_rust_http_response {
fn new_with_null_ptr() -> Self {
Self {
status_code: Default::default(),
headers: core::ptr::null_mut(),
url: core::ptr::null_mut(),
content_length: core::ptr::null_mut(),
version: Default::default(),
remote_addr: core::ptr::null_mut(),
data: core::ptr::null_mut(),
}
}
}
impl Default for wire_cst_rust_http_response {
fn default() -> Self {
Self::new_with_null_ptr()
}
}
#[no_mangle]
pub extern "C" fn frbgen_starcitizen_doctor_wire__crate__api__http_api__dns_lookup_ips(
port_: i64,
host: *mut wire_cst_list_prim_u_8_strict,
) {
wire__crate__api__http_api__dns_lookup_ips_impl(port_, host)
}
#[no_mangle]
pub extern "C" fn frbgen_starcitizen_doctor_wire__crate__api__http_api__dns_lookup_txt(
port_: i64,
host: *mut wire_cst_list_prim_u_8_strict,
) {
wire__crate__api__http_api__dns_lookup_txt_impl(port_, host)
}
#[no_mangle]
pub extern "C" fn frbgen_starcitizen_doctor_wire__crate__api__http_api__fetch(
port_: i64,
method: i32,
url: *mut wire_cst_list_prim_u_8_strict,
headers: *mut wire_cst_list_record_string_string,
input_data: *mut wire_cst_list_prim_u_8_strict,
with_ip_address: *mut wire_cst_list_prim_u_8_strict,
with_custom_dns: *mut bool,
2024-07-07 16:50:23 +08:00
) {
wire__crate__api__http_api__fetch_impl(
port_,
method,
url,
headers,
input_data,
with_ip_address,
with_custom_dns,
2024-07-07 16:50:23 +08:00
)
}
#[no_mangle]
pub extern "C" fn frbgen_starcitizen_doctor_wire__crate__api__asar_api__get_rsi_launcher_asar_data(
port_: i64,
asar_path: *mut wire_cst_list_prim_u_8_strict,
) {
wire__crate__api__asar_api__get_rsi_launcher_asar_data_impl(port_, asar_path)
}
#[no_mangle]
pub extern "C" fn frbgen_starcitizen_doctor_wire__crate__api__asar_api__rsi_launcher_asar_data_write_main_js(
port_: i64,
that: *mut wire_cst_rsi_launcher_asar_data,
content: *mut wire_cst_list_prim_u_8_loose,
) {
wire__crate__api__asar_api__rsi_launcher_asar_data_write_main_js_impl(port_, that, content)
}
#[no_mangle]
pub extern "C" fn frbgen_starcitizen_doctor_wire__crate__api__win32_api__send_notify(
port_: i64,
summary: *mut wire_cst_list_prim_u_8_strict,
body: *mut wire_cst_list_prim_u_8_strict,
app_name: *mut wire_cst_list_prim_u_8_strict,
app_id: *mut wire_cst_list_prim_u_8_strict,
) {
wire__crate__api__win32_api__send_notify_impl(port_, summary, body, app_name, app_id)
}
2024-07-07 16:50:23 +08:00
#[no_mangle]
pub extern "C" fn frbgen_starcitizen_doctor_wire__crate__api__http_api__set_default_header(
port_: i64,
headers: *mut wire_cst_list_record_string_string,
) {
wire__crate__api__http_api__set_default_header_impl(port_, headers)
}
#[no_mangle]
pub extern "C" fn frbgen_starcitizen_doctor_wire__crate__api__win32_api__set_foreground_window(
port_: i64,
window_name: *mut wire_cst_list_prim_u_8_strict,
) {
wire__crate__api__win32_api__set_foreground_window_impl(port_, window_name)
}
2024-07-07 16:50:23 +08:00
#[no_mangle]
pub extern "C" fn frbgen_starcitizen_doctor_wire__crate__api__rs_process__start(
port_: i64,
executable: *mut wire_cst_list_prim_u_8_strict,
arguments: *mut wire_cst_list_String,
working_directory: *mut wire_cst_list_prim_u_8_strict,
stream_sink: *mut wire_cst_list_prim_u_8_strict,
) {
wire__crate__api__rs_process__start_impl(
port_,
executable,
arguments,
working_directory,
stream_sink,
)
}
#[no_mangle]
pub extern "C" fn frbgen_starcitizen_doctor_wire__crate__api__rs_process__write(
port_: i64,
rs_pid: u32,
data: *mut wire_cst_list_prim_u_8_strict,
) {
wire__crate__api__rs_process__write_impl(port_, rs_pid, data)
}
#[no_mangle]
pub extern "C" fn frbgen_starcitizen_doctor_cst_new_box_autoadd_bool(value: bool) -> *mut bool {
flutter_rust_bridge::for_generated::new_leak_box_ptr(value)
}
2024-07-07 16:50:23 +08:00
#[no_mangle]
pub extern "C" fn frbgen_starcitizen_doctor_cst_new_box_autoadd_rsi_launcher_asar_data(
) -> *mut wire_cst_rsi_launcher_asar_data {
flutter_rust_bridge::for_generated::new_leak_box_ptr(
wire_cst_rsi_launcher_asar_data::new_with_null_ptr(),
)
}
#[no_mangle]
pub extern "C" fn frbgen_starcitizen_doctor_cst_new_box_autoadd_u_64(value: u64) -> *mut u64 {
flutter_rust_bridge::for_generated::new_leak_box_ptr(value)
}
#[no_mangle]
pub extern "C" fn frbgen_starcitizen_doctor_cst_new_list_String(
len: i32,
) -> *mut wire_cst_list_String {
let wrap = wire_cst_list_String {
ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
<*mut wire_cst_list_prim_u_8_strict>::new_with_null_ptr(),
len,
),
len,
};
flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
}
#[no_mangle]
pub extern "C" fn frbgen_starcitizen_doctor_cst_new_list_prim_u_8_loose(
len: i32,
) -> *mut wire_cst_list_prim_u_8_loose {
let ans = wire_cst_list_prim_u_8_loose {
ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(Default::default(), len),
len,
};
flutter_rust_bridge::for_generated::new_leak_box_ptr(ans)
}
#[no_mangle]
pub extern "C" fn frbgen_starcitizen_doctor_cst_new_list_prim_u_8_strict(
len: i32,
) -> *mut wire_cst_list_prim_u_8_strict {
let ans = wire_cst_list_prim_u_8_strict {
ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(Default::default(), len),
len,
};
flutter_rust_bridge::for_generated::new_leak_box_ptr(ans)
}
#[no_mangle]
pub extern "C" fn frbgen_starcitizen_doctor_cst_new_list_record_string_string(
len: i32,
) -> *mut wire_cst_list_record_string_string {
let wrap = wire_cst_list_record_string_string {
ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
<wire_cst_record_string_string>::new_with_null_ptr(),
len,
),
len,
};
flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
}
#[repr(C)]
#[derive(Clone, Copy)]
pub struct wire_cst_list_String {
ptr: *mut *mut wire_cst_list_prim_u_8_strict,
len: i32,
}
#[repr(C)]
#[derive(Clone, Copy)]
pub struct wire_cst_list_prim_u_8_loose {
ptr: *mut u8,
len: i32,
}
#[repr(C)]
#[derive(Clone, Copy)]
pub struct wire_cst_list_prim_u_8_strict {
ptr: *mut u8,
len: i32,
}
#[repr(C)]
#[derive(Clone, Copy)]
pub struct wire_cst_list_record_string_string {
ptr: *mut wire_cst_record_string_string,
len: i32,
}
#[repr(C)]
#[derive(Clone, Copy)]
pub struct wire_cst_record_string_string {
field0: *mut wire_cst_list_prim_u_8_strict,
field1: *mut wire_cst_list_prim_u_8_strict,
}
#[repr(C)]
#[derive(Clone, Copy)]
pub struct wire_cst_rs_process_stream_data {
data_type: i32,
data: *mut wire_cst_list_prim_u_8_strict,
rs_pid: u32,
}
#[repr(C)]
#[derive(Clone, Copy)]
pub struct wire_cst_rsi_launcher_asar_data {
asar_path: *mut wire_cst_list_prim_u_8_strict,
main_js_path: *mut wire_cst_list_prim_u_8_strict,
main_js_content: *mut wire_cst_list_prim_u_8_strict,
}
#[repr(C)]
#[derive(Clone, Copy)]
pub struct wire_cst_rust_http_response {
status_code: u16,
headers: *mut wire_cst_list_record_string_string,
url: *mut wire_cst_list_prim_u_8_strict,
content_length: *mut u64,
version: i32,
remote_addr: *mut wire_cst_list_prim_u_8_strict,
data: *mut wire_cst_list_prim_u_8_strict,
}
}
2024-02-06 20:19:53 +08:00
#[cfg(not(target_family = "wasm"))]
pub use io::*;