SCToolBox/app
1
0
Fork 0
mirror of https://ghfast.top/https://github.com/StarCitizenToolBox/app.git synced 2025-06-28 04:24:45 +08:00
Code Issues Packages Projects Releases Wiki Activity

feat: Optimize RsProcess

Browse Source
This commit is contained in:
xkeyC
2024-04-17 21:40:08 +08:00
parent 603ef46f10
commit 097b9d9bce
8 changed files with 219 additions and 899 deletions
Download Patch File Download Diff File Expand all files Collapse all files

209
rust/src/api/rs_process.rs
View File

@ -1,19 +1,17 @@
use flutter_rust_bridge::for_generated::futures::lock::Mutex;
use std::collections::HashMap;
use std::sync::Arc;
use async_std::task::block_on;
use flutter_rust_bridge::frb;
use lazy_static::lazy_static;
use scopeguard::defer;
use tokio::io::AsyncBufReadExt;
use tokio::io::AsyncWriteExt;
use tokio::io::BufReader;
use tokio::io::{AsyncBufReadExt, AsyncWriteExt};
use tokio::process::ChildStdin;
use tokio::sync::Mutex;
use crate::frb_generated::StreamSink;
#[frb(opaque)]
pub struct RsProcess {
child_stdin: Option<Arc<Mutex<ChildStdin>>>,
pid: Option<u32>,
}
#[derive(Clone, Copy)]
pub enum RsProcessStreamDataType {
Output,
@ -24,118 +22,130 @@ pub enum RsProcessStreamDataType {
pub struct RsProcessStreamData {
pub data_type: RsProcessStreamDataType,
pub data: String,
pub rs_pid: u32,
}
impl RsProcess {
#[frb(sync)]
pub fn new() -> Self {
RsProcess {
child_stdin: None,
pid: None,
pub struct RsProcess {
pub child_stdin: ChildStdin,
pub rs_pid: u32,
}
lazy_static! {
static ref RS_PROCESS_MAP: Mutex<HashMap<u32, RsProcess>> = Mutex::new(HashMap::new());
}
pub async fn start(
executable: String,
arguments: Vec<String>,
working_directory: String,
stream_sink: StreamSink<RsProcessStreamData>,
) {
let stream_sink_arc = Arc::from(stream_sink);
let mut command = tokio::process::Command::new(executable);
command
.args(arguments)
.current_dir(working_directory)
.stdin(std::process::Stdio::piped())
.stdout(std::process::Stdio::piped())
.stderr(std::process::Stdio::piped())
.kill_on_drop(true);
command.creation_flags(0x08000000);
let job = win32job::Job::create().unwrap();
let mut info = job.query_extended_limit_info().unwrap();
info.limit_kill_on_job_close();
job.set_extended_limit_info(&mut info).unwrap();
let job_arc = Arc::from(job);
if let Ok(mut child) = command.spawn() {
{
let raw_handle = child.raw_handle();
if raw_handle.is_some() {
job_arc
.assign_process(raw_handle.unwrap() as isize)
.unwrap();
}
}
}
pub async fn start(
&mut self,
executable: String,
arguments: Vec<String>,
working_directory: String,
stream_sink: StreamSink<RsProcessStreamData>,
) {
let stream_sink_arc = Arc::from(stream_sink);
let stdin = child.stdin.take().expect("[rs_process] Failed to open stdin");
let pid = child.id().expect("[rs_process] Failed to get pid");
{
let mut map = RS_PROCESS_MAP.lock().await;
map.insert(
pid,
RsProcess {
child_stdin: stdin,
rs_pid: pid,
},
);
}
let mut command = tokio::process::Command::new(executable);
command
.args(arguments)
.current_dir(working_directory)
.stdin(std::process::Stdio::piped())
.stdout(std::process::Stdio::piped())
.stderr(std::process::Stdio::piped())
.kill_on_drop(true);
defer! {
let mut map = block_on(RS_PROCESS_MAP.lock());
map.remove(&pid);
println!("RS_PROCESS_MAP ..defer ..len() = {}", map.len());
}
command.creation_flags(0x08000000);
let stdout = child.stdout.take().expect("[rs_process] Failed to open stdout");
let stderr = child.stderr.take().expect("[rs_process] Failed to open stderr");
let job = win32job::Job::create().unwrap();
let mut info = job.query_extended_limit_info().unwrap();
info.limit_kill_on_job_close();
job.set_extended_limit_info(&mut info).unwrap();
let output_task = tokio::spawn(_process_output(
stdout,
stream_sink_arc.clone(),
RsProcessStreamDataType::Output,
pid,
));
let error_task = tokio::spawn(_process_output(
stderr,
stream_sink_arc.clone(),
RsProcessStreamDataType::Error,
pid,
));
let job_arc = Arc::from(job);
tokio::select! {_ = output_task => (), _ = error_task => () }
if let Ok(mut child) = command.spawn() {
{
let raw_handle = child.raw_handle();
if raw_handle.is_some() {
job_arc
.assign_process(raw_handle.unwrap() as isize)
.unwrap();
}
}
let exit_status = child
.wait()
.await
.expect("[rs_process] Failed to wait for child process");
let stdout = child.stdout.take().expect("Failed to open stdout");
let stderr = child.stderr.take().expect("Failed to open stderr");
let stdin = child.stdin.take().expect("Failed to open stdin");
self.child_stdin = Some(Arc::from(Mutex::new(stdin)));
let output_task = tokio::spawn(_process_output(
stdout,
stream_sink_arc.clone(),
RsProcessStreamDataType::Output,
));
let error_task = tokio::spawn(_process_output(
stderr,
stream_sink_arc.clone(),
RsProcessStreamDataType::Error,
));
self.pid = child.id();
tokio::select! {
_ = output_task => (),
_ = error_task => (),
}
let exit_status = child
.wait()
.await
.expect("Failed to wait for child process");
if !exit_status.success() {
eprintln!("Child process exited with an error: {:?}", exit_status);
let message = RsProcessStreamData {
data_type: RsProcessStreamDataType::Exit,
data: "exit".to_string(),
};
stream_sink_arc.add(message).unwrap();
}
} else {
eprintln!("Failed to start");
if !exit_status.success() {
println!("[rs_process] Child process exited with an error: {:?}", exit_status);
let message = RsProcessStreamData {
data_type: RsProcessStreamDataType::Error,
data: "Failed to start".to_string(),
data_type: RsProcessStreamDataType::Exit,
data: "exit".to_string(),
rs_pid: pid,
};
stream_sink_arc.add(message).unwrap();
}
} else {
println!("Failed to start");
let message = RsProcessStreamData {
data_type: RsProcessStreamDataType::Error,
data: "Failed to start".to_string(),
rs_pid: 0,
};
stream_sink_arc.add(message).unwrap();
}
}
pub async fn write(&mut self, data: String) {
if let Some(stdin) = &self.child_stdin {
let mut stdin_lock = stdin.lock().await;
stdin_lock.write_all(data.as_bytes()).await.unwrap();
}
}
#[frb(sync)]
pub fn get_pid(&self) -> Option<u32> {
self.pid
}
pub async fn write(rs_pid: &u32, data: String) {
let mut map = RS_PROCESS_MAP.lock().await;
let process = map.get_mut(rs_pid).unwrap();
process
.child_stdin
.write_all(data.as_bytes())
.await
.unwrap();
}
async fn _process_output<R>(
stdout: R,
stream_sink: Arc<StreamSink<RsProcessStreamData>>,
data_type: RsProcessStreamDataType,
pid: u32,
) where
R: tokio::io::AsyncRead + Unpin,
{
@ -146,6 +156,7 @@ async fn _process_output<R>(
let message = RsProcessStreamData {
data_type,
data: line.trim().parse().unwrap(),
rs_pid: pid,
};
stream_sink.add(message).unwrap();
}

80
rust/src/frb_generated.io.rs
View File

@ -4,7 +4,6 @@
// Section: imports
use super::*;
use crate::api::rs_process::*;
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};
@ -23,12 +22,6 @@ impl CstDecode<flutter_rust_bridge::for_generated::anyhow::Error>
unimplemented!()
}
}
impl CstDecode<RsProcess> for usize {
// Codec=Cst (C-struct based), see doc to use other codecs
fn cst_decode(self) -> RsProcess {
CstDecode::<RustOpaqueNom<flutter_rust_bridge::for_generated::rust_async::RwLock<RsProcess>>>::cst_decode(self).rust_auto_opaque_decode_owned()
}
}
impl CstDecode<std::collections::HashMap<String, String>>
for *mut wire_cst_list_record_string_string
{
@ -38,16 +31,6 @@ impl CstDecode<std::collections::HashMap<String, String>>
vec.into_iter().collect()
}
}
impl CstDecode<RustOpaqueNom<flutter_rust_bridge::for_generated::rust_async::RwLock<RsProcess>>>
for usize
{
// Codec=Cst (C-struct based), see doc to use other codecs
fn cst_decode(
self,
) -> RustOpaqueNom<flutter_rust_bridge::for_generated::rust_async::RwLock<RsProcess>> {
unsafe { decode_rust_opaque_nom(self as _) }
}
}
impl
CstDecode<
StreamSink<
@ -74,12 +57,6 @@ impl CstDecode<String> for *mut wire_cst_list_prim_u_8_strict {
String::from_utf8(vec).unwrap()
}
}
impl CstDecode<u32> for *mut u32 {
// Codec=Cst (C-struct based), see doc to use other codecs
fn cst_decode(self) -> u32 {
unsafe { *flutter_rust_bridge::for_generated::box_from_leak_ptr(self) }
}
}
impl CstDecode<u64> for *mut u64 {
// Codec=Cst (C-struct based), see doc to use other codecs
fn cst_decode(self) -> u64 {
@ -127,6 +104,7 @@ impl CstDecode<crate::api::rs_process::RsProcessStreamData> for wire_cst_rs_proc
crate::api::rs_process::RsProcessStreamData {
data_type: self.data_type.cst_decode(),
data: self.data.cst_decode(),
rs_pid: self.rs_pid.cst_decode(),
}
}
}
@ -162,6 +140,7 @@ impl NewWithNullPtr for wire_cst_rs_process_stream_data {
Self {
data_type: Default::default(),
data: core::ptr::null_mut(),
rs_pid: Default::default(),
}
}
}
@ -226,67 +205,23 @@ pub extern "C" fn frbgen_starcitizen_doctor_wire_set_default_header(
}
#[no_mangle]
pub extern "C" fn frbgen_starcitizen_doctor_wire_RsProcess_get_pid(
that: usize,
) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
wire_RsProcess_get_pid_impl(that)
}
#[no_mangle]
pub extern "C" fn frbgen_starcitizen_doctor_wire_RsProcess_new(
) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
wire_RsProcess_new_impl()
}
#[no_mangle]
pub extern "C" fn frbgen_starcitizen_doctor_wire_RsProcess_start(
pub extern "C" fn frbgen_starcitizen_doctor_wire_start(
port_: i64,
that: usize,
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_RsProcess_start_impl(
port_,
that,
executable,
arguments,
working_directory,
stream_sink,
)
wire_start_impl(port_, executable, arguments, working_directory, stream_sink)
}
#[no_mangle]
pub extern "C" fn frbgen_starcitizen_doctor_wire_RsProcess_write(
pub extern "C" fn frbgen_starcitizen_doctor_wire_write(
port_: i64,
that: usize,
rs_pid: u32,
data: *mut wire_cst_list_prim_u_8_strict,
) {
wire_RsProcess_write_impl(port_, that, data)
}
#[no_mangle]
pub extern "C" fn frbgen_starcitizen_doctor_rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedrust_asyncRwLockRsProcess(
ptr: *const std::ffi::c_void,
) {
unsafe {
StdArc::<flutter_rust_bridge::for_generated::rust_async::RwLock<RsProcess>>::increment_strong_count(ptr as _);
}
}
#[no_mangle]
pub extern "C" fn frbgen_starcitizen_doctor_rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedrust_asyncRwLockRsProcess(
ptr: *const std::ffi::c_void,
) {
unsafe {
StdArc::<flutter_rust_bridge::for_generated::rust_async::RwLock<RsProcess>>::decrement_strong_count(ptr as _);
}
}
#[no_mangle]
pub extern "C" fn frbgen_starcitizen_doctor_cst_new_box_autoadd_u_32(value: u32) -> *mut u32 {
flutter_rust_bridge::for_generated::new_leak_box_ptr(value)
wire_write_impl(port_, rs_pid, data)
}
#[no_mangle]
@ -362,6 +297,7 @@ pub struct wire_cst_record_string_string {
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)]

163
rust/src/frb_generated.rs
View File

@ -19,7 +19,6 @@
// Section: imports
use crate::api::rs_process::*;
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};
@ -32,7 +31,7 @@ flutter_rust_bridge::frb_generated_boilerplate!(
default_rust_auto_opaque = RustAutoOpaqueNom,
);
pub(crate) const FLUTTER_RUST_BRIDGE_CODEGEN_VERSION: &str = "2.0.0-dev.32";
pub(crate) const FLUTTER_RUST_BRIDGE_CODEGEN_CONTENT_HASH: i32 = 333909092;
pub(crate) const FLUTTER_RUST_BRIDGE_CODEGEN_CONTENT_HASH: i32 = 1270049297;
// Section: executor
@ -140,45 +139,8 @@ fn wire_set_default_header_impl(
},
)
}
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(
fn wire_start_impl(
port_: flutter_rust_bridge::for_generated::MessagePort,
that: impl CstDecode<
RustOpaqueNom<flutter_rust_bridge::for_generated::rust_async::RwLock<RsProcess>>,
>,
executable: impl CstDecode<String>,
arguments: impl CstDecode<Vec<String>>,
working_directory: impl CstDecode<String>,
@ -191,12 +153,11 @@ fn wire_RsProcess_start_impl(
) {
FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
flutter_rust_bridge::for_generated::TaskInfo {
debug_name: "RsProcess_start",
debug_name: "start",
port: Some(port_),
mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
},
move || {
let api_that = that.cst_decode();
let api_executable = executable.cst_decode();
let api_arguments = arguments.cst_decode();
let api_working_directory = working_directory.cst_decode();
@ -204,10 +165,8 @@ fn wire_RsProcess_start_impl(
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::start(
&mut api_that,
crate::api::rs_process::start(
api_executable,
api_arguments,
api_working_directory,
@ -222,28 +181,25 @@ fn wire_RsProcess_start_impl(
},
)
}
fn wire_RsProcess_write_impl(
fn wire_write_impl(
port_: flutter_rust_bridge::for_generated::MessagePort,
that: impl CstDecode<
RustOpaqueNom<flutter_rust_bridge::for_generated::rust_async::RwLock<RsProcess>>,
>,
rs_pid: impl CstDecode<u32>,
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",
debug_name: "write",
port: Some(port_),
mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
},
move || {
let api_that = that.cst_decode();
let api_rs_pid = rs_pid.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,
crate::api::rs_process::write(&api_rs_pid, api_data).await,
)
})()
.await,
@ -327,12 +283,6 @@ impl CstDecode<u8> for u8 {
self
}
}
impl CstDecode<usize> for usize {
// Codec=Cst (C-struct based), see doc to use other codecs
fn cst_decode(self) -> usize {
self
}
}
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 {
@ -340,16 +290,6 @@ impl SseDecode for flutter_rust_bridge::for_generated::anyhow::Error {
}
}
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();
}
}
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 {
@ -358,16 +298,6 @@ impl SseDecode for std::collections::HashMap<String, String> {
}
}
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,
@ -491,17 +421,6 @@ impl SseDecode for Option<String> {
}
}
impl SseDecode for Option<u32> {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
if (<bool>::sse_decode(deserializer)) {
return Some(<u32>::sse_decode(deserializer));
} else {
return None;
}
}
}
impl SseDecode for Option<u64> {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
@ -539,9 +458,11 @@ impl SseDecode for crate::api::rs_process::RsProcessStreamData {
let mut var_dataType =
<crate::api::rs_process::RsProcessStreamDataType>::sse_decode(deserializer);
let mut var_data = <String>::sse_decode(deserializer);
let mut var_rsPid = <u32>::sse_decode(deserializer);
return crate::api::rs_process::RsProcessStreamData {
data_type: var_dataType,
data: var_data,
rs_pid: var_rsPid,
};
}
}
@ -614,13 +535,6 @@ impl SseDecode for () {
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {}
}
impl SseDecode for usize {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
deserializer.cursor.read_u64::<NativeEndian>().unwrap() as _
}
}
impl SseDecode for bool {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
@ -655,21 +569,6 @@ fn pde_ffi_dispatcher_sync_impl(
// Section: rust2dart
// 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()
}
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for crate::http_package::MyHttpVersion {
fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
@ -727,6 +626,7 @@ impl flutter_rust_bridge::IntoDart for crate::api::rs_process::RsProcessStreamDa
[
self.data_type.into_into_dart().into_dart(),
self.data.into_into_dart().into_dart(),
self.rs_pid.into_into_dart().into_dart(),
]
.into_dart()
}
@ -797,13 +697,6 @@ impl SseEncode for flutter_rust_bridge::for_generated::anyhow::Error {
}
}
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);
}
}
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) {
@ -811,17 +704,6 @@ impl SseEncode for std::collections::HashMap<String, String> {
}
}
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,
@ -941,16 +823,6 @@ impl SseEncode for Option<String> {
}
}
impl SseEncode for Option<u32> {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
<bool>::sse_encode(self.is_some(), serializer);
if let Some(value) = self {
<u32>::sse_encode(value, serializer);
}
}
}
impl SseEncode for Option<u64> {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
@ -984,6 +856,7 @@ impl SseEncode for crate::api::rs_process::RsProcessStreamData {
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);
<u32>::sse_encode(self.rs_pid, serializer);
}
}
@ -1050,16 +923,6 @@ impl SseEncode for () {
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {}
}
impl SseEncode for usize {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
serializer
.cursor
.write_u64::<NativeEndian>(self as _)
.unwrap();
}
}
impl SseEncode for bool {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {