Page MenuHomePhabricator
Differential D4837

[native] Fix up redux-persist types
ClosedPublic
Actions

Authored by ashoat on Aug 15 2022, 1:06 PM.
Tags
None
Referenced Files
Unknown Object (File)
Tue, Apr 22, 6:09 PM
Unknown Object (File)
Wed, Apr 9, 12:05 AM
Unknown Object (File)
Sat, Apr 5, 10:27 AM
Unknown Object (File)
Feb 18 2025, 9:13 AM
Unknown Object (File)
Feb 7 2025, 1:15 AM
Unknown Object (File)
Feb 3 2025, 2:19 PM
Unknown Object (File)
Jan 30 2025, 5:36 PM
Unknown Object (File)
Jan 30 2025, 5:36 PM
View All 85 Files
Subscribers
• abosh
• adrian
atul

Details

Reviewers
tomek
Commits
rCOMM722474a2e0fe: [native] Fix up redux-persist types
Summary

This resolves ENG-1593. See this comment.

Test Plan

Flow

Diff Detail

Repository
rCOMM Comm
Branch
ashoat/reduxPersistFlow
Lint
No Lint Coverage
Unit
No Test Coverage

Revision Contents
Changeset List

PathSize
native/
1 line
flow-typed/
npm/
patches/
24 lines

Diff 15625

View Options

native/.flowconfig

#[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!();
} }
View Options

native/flow-typed/npm/redux-persist_vx.x.x.js

#[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!();
} }
View Options

patches/redux-persist+6.0.0.patch

#[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!();
} }