#[cxx::bridge]		#[cxx::bridge]
mod ffi {		mod ffi {
extern "Rust" {		extern "Rust" {
fn rust_is_initialized_cxx() -> bool;		fn rust_is_initialized_cxx() -> bool;
fn rust_initialize_cxx() -> ();		fn rust_initialize_cxx() -> ();
unsafe fn rust_process_cxx(_: *const c_char) -> ();		unsafe fn rust_process_cxx(data: *const c_char) -> ();
fn rust_terminate_cxx() -> ();		fn rust_terminate_cxx() -> ();
}		}
}		}

mod constants;		mod constants;

use constants::MPSC_CHANNEL_BUFFER_CAPACITY;		use constants::MPSC_CHANNEL_BUFFER_CAPACITY;
use tokio::runtime::Runtime;		use tokio::runtime::Runtime;
use tokio::sync::mpsc;		use tokio::sync::mpsc;
use tokio::task::JoinHandle;		use tokio::task::JoinHandle;
use lazy_static::lazy_static;		use lazy_static::lazy_static;
use std::sync::{Arc, Mutex};		use std::sync::{Arc, Mutex};
extern crate libc;		extern crate libc;
use libc::c_char;		use libc::c_char;
		use std::ffi::CStr;

pub struct Client {		pub struct Client {
tx: Option<mpsc::Sender<String>>,		tx: Option<mpsc::Sender<String>>,
handle: Option<JoinHandle<()>>,		handle: Option<JoinHandle<()>>,
}		}

lazy_static! {		lazy_static! {
pub static ref CLIENT: Arc<Mutex<Client>> = Arc::new(Mutex::new(Client {		pub static ref CLIENT: Arc<Mutex<Client>> = Arc::new(Mutex::new(Client {
Show All 25 Lines	let handle = RUNTIME.spawn(async move {
}		}
println!("[RUST] [receiver] done");		println!("[RUST] [receiver] done");
});		});
CLIENT.lock().expect("access client").handle = Some(handle);		CLIENT.lock().expect("access client").handle = Some(handle);
CLIENT.lock().expect("access client").tx = Some(tx);		CLIENT.lock().expect("access client").tx = Some(tx);
println!("[RUST] initialized");		println!("[RUST] initialized");
}		}

pub fn rust_process_cxx(_: *const c_char) -> () {		pub fn rust_process_cxx(data: *const c_char) -> () {
unimplemented!();		println!("[RUST] [rust_process] begin");
		let c_str: &CStr = unsafe { CStr::from_ptr(data) };
		let str: String = c_str.to_str().unwrap().to_owned();
		tomekUnsubmitted Not Done Inline Actions Using `str` as a name sounds confusing. Can we use a name that isn't also a type name? tomek: Using `str` as a name sounds confusing. Can we use a name that isn't also a type name?
		karolAuthorUnsubmitted Done Inline Actions sure, whatever karol: sure, whatever
		println!("[RUST] [rust_process] data string: {}", str);

		// this works
		tomekUnsubmitted Not Done Inline Actions I guess we can remove this tomek: I guess we can remove this
		karolAuthorUnsubmitted Done Inline Actions right karol: right
		RUNTIME.block_on(async {
		CLIENT
		.lock()
		.expect("access client")
		.tx
		tomekUnsubmitted Not Done Inline Actions Does that mean that we can write only from one thread at a time? Doesn't sounds like an issue, just wanted to clarify. tomek: Does that mean that we can write only from one thread at a time? Doesn't sounds like an issue…
		karolAuthorUnsubmitted Done Inline Actions yes karol: yes
		.as_ref()
		.expect("access client's transmitter")
		.send(str)
		.await
		.expect("send data to receiver");
		});
		println!("[RUST] [rust_process] end");
}		}

pub fn rust_terminate_cxx() -> () {		pub fn rust_terminate_cxx() -> () {
unimplemented!();		unimplemented!();
}		}

[lib] Change definition of useEditMessage functionClosedPublicActions

Details

Diff Detail

Event Timeline

Revision ContentsChangeset List

Diff 25093

lib/shared/edit-messages-utils.js

[lib] Change definition of useEditMessage function
ClosedPublic
Actions

Revision Contents
Changeset List