mirrors/loro
1
0
Fork 0
mirror of https://github.com/loro-dev/loro.git synced 2025-02-02 11:06:14 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

refactor: replace i32 with i64 (#269)

Browse source
This commit is contained in:
Zixuan Chen 2024-02-18 17:27:33 +08:00 committed by GitHub
parent 751082f307
commit bd57eb52b1
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
10 changed files with 68 additions and 48 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

8
crates/examples/src/draw.rs
View file

@ -127,13 +127,13 @@ impl ActorTrait for DrawActor {
let map = self.doc.get_map(id);
let pos_map = map.get("pos").unwrap().unwrap_right().into_map().unwrap();
let x = pos_map.get("x").unwrap().unwrap_left().into_i32().unwrap();
let y = pos_map.get("y").unwrap().unwrap_left().into_i32().unwrap();
let x = pos_map.get("x").unwrap().unwrap_left().into_i64().unwrap();
let y = pos_map.get("y").unwrap().unwrap_left().into_i64().unwrap();
pos_map
.insert("x", x.overflowing_add(relative_to.x).0)
.insert("x", x.overflowing_add(relative_to.x as i64).0)
.unwrap();
pos_map
.insert("y", y.overflowing_add(relative_to.y).0)
.insert("y", y.overflowing_add(relative_to.y as i64).0)
.unwrap();
}
}

2
crates/loro-common/src/macros.rs
View file

@ -293,7 +293,7 @@ mod test {
assert!(!(*map.get("false").unwrap().as_bool().unwrap()));
assert!(map.get("null").unwrap().is_null());
assert_eq!(map.get("list").unwrap().as_list().unwrap().len(), 0);
assert_eq!(*map.get("integer").unwrap().as_i32().unwrap(), 123);
assert_eq!(*map.get("integer").unwrap().as_i64().unwrap(), 123);
assert_eq!(*map.get("float").unwrap().as_double().unwrap(), 123.123);
assert_eq!(map.get("map").unwrap().as_map().unwrap().len(), 1);
assert_eq!(

44
crates/loro-common/src/value.rs
View file

@ -15,7 +15,7 @@ pub enum LoroValue {
Null,
Bool(bool),
Double(f64),
I32(i32),
I64(i64),
// i64?
Binary(Arc<Vec<u8>>),
String(Arc<String>),
@ -32,7 +32,7 @@ impl<'a> arbitrary::Arbitrary<'a> for LoroValue {
0 => LoroValue::Null,
1 => LoroValue::Bool(u.arbitrary()?),
2 => LoroValue::Double(u.arbitrary()?),
3 => LoroValue::I32(u.arbitrary()?),
3 => LoroValue::I64(u.arbitrary()?),
4 => LoroValue::Binary(Arc::new(u.arbitrary()?)),
5 => LoroValue::String(Arc::new(u.arbitrary()?)),
6 => LoroValue::List(Arc::new(u.arbitrary()?)),
@ -151,7 +151,7 @@ impl TryFrom<LoroValue> for i32 {
fn try_from(value: LoroValue) -> Result<Self, Self::Error> {
match value {
LoroValue::I32(v) => Ok(v),
LoroValue::I64(v) => Ok(v as i32),
_ => Err("not a i32"),
}
}
@ -223,8 +223,8 @@ impl Hash for LoroValue {
LoroValue::Double(v) => {
state.write_u64(v.to_bits());
}
LoroValue::I32(v) => {
state.write_i32(*v);
LoroValue::I64(v) => {
state.write_i64(*v);
}
LoroValue::Binary(v) => {
v.hash(state);
@ -282,19 +282,31 @@ impl<const N: usize> From<&'_ [u8; N]> for LoroValue {
impl From<i32> for LoroValue {
fn from(v: i32) -> Self {
LoroValue::I32(v)
LoroValue::I64(v as i64)
}
}
impl From<u32> for LoroValue {
fn from(v: u32) -> Self {
LoroValue::I64(v as i64)
}
}
impl From<i64> for LoroValue {
fn from(v: i64) -> Self {
LoroValue::I64(v)
}
}
impl From<u16> for LoroValue {
fn from(v: u16) -> Self {
LoroValue::I32(v as i32)
LoroValue::I64(v as i64)
}
}
impl From<i16> for LoroValue {
fn from(v: i16) -> Self {
LoroValue::I32(v as i32)
LoroValue::I64(v as i64)
}
}
@ -356,7 +368,7 @@ pub mod wasm {
LoroValue::Null => JsValue::NULL,
LoroValue::Bool(b) => JsValue::from_bool(b),
LoroValue::Double(f) => JsValue::from_f64(f),
LoroValue::I32(i) => JsValue::from_f64(i as f64),
LoroValue::I64(i) => JsValue::from_f64(i as f64),
LoroValue::String(s) => JsValue::from_str(&s),
LoroValue::Binary(binary) => {
let binary = Arc::try_unwrap(binary).unwrap_or_else(|m| (*m).clone());
@ -402,8 +414,8 @@ pub mod wasm {
LoroValue::Bool(js_value.as_bool().unwrap())
} else if js_value.as_f64().is_some() {
let num = js_value.as_f64().unwrap();
if num.fract() == 0.0 && num <= i32::MAX as f64 && num >= i32::MIN as f64 {
LoroValue::I32(num as i32)
if num.fract() == 0.0 && num <= i64::MAX as f64 && num >= i64::MIN as f64 {
LoroValue::I64(num as i64)
} else {
LoroValue::Double(num)
}
@ -472,7 +484,7 @@ impl Serialize for LoroValue {
LoroValue::Null => serializer.serialize_unit(),
LoroValue::Bool(b) => serializer.serialize_bool(*b),
LoroValue::Double(d) => serializer.serialize_f64(*d),
LoroValue::I32(i) => serializer.serialize_i32(*i),
LoroValue::I64(i) => serializer.serialize_i64(*i),
LoroValue::String(s) => serializer.serialize_str(s),
LoroValue::Binary(b) => serializer.collect_seq(b.iter()),
LoroValue::List(l) => serializer.collect_seq(l.iter()),
@ -493,7 +505,7 @@ impl Serialize for LoroValue {
LoroValue::Double(d) => {
serializer.serialize_newtype_variant("LoroValue", 2, "Double", d)
}
LoroValue::I32(i) => serializer.serialize_newtype_variant("LoroValue", 3, "I32", i),
LoroValue::I64(i) => serializer.serialize_newtype_variant("LoroValue", 3, "I32", i),
LoroValue::String(s) => {
serializer.serialize_newtype_variant("LoroValue", 4, "String", &**s)
}
@ -569,14 +581,14 @@ impl<'de> serde::de::Visitor<'de> for LoroValueVisitor {
where
E: serde::de::Error,
{
Ok(LoroValue::I32(v as i32))
Ok(LoroValue::I64(v))
}
fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
where
E: serde::de::Error,
{
Ok(LoroValue::I32(v as i32))
Ok(LoroValue::I64(v as i64))
}
fn visit_f64<E>(self, v: f64) -> Result<Self::Value, E>
@ -673,7 +685,7 @@ impl<'de> serde::de::Visitor<'de> for LoroValueEnumVisitor {
}
(LoroValueFields::Bool, v) => v.newtype_variant().map(LoroValue::Bool),
(LoroValueFields::Double, v) => v.newtype_variant().map(LoroValue::Double),
(LoroValueFields::I32, v) => v.newtype_variant().map(LoroValue::I32),
(LoroValueFields::I32, v) => v.newtype_variant().map(LoroValue::I64),
(LoroValueFields::String, v) => {
v.newtype_variant().map(|x| LoroValue::String(Arc::new(x)))
}

42
crates/loro-internal/src/encoding/encode_reordered.rs
View file

@ -886,7 +886,7 @@ mod encode {
}
pub(super) fn encode_changes<'a>(
diff_changes: &'a Vec<Cow<'a, Change>>,
diff_changes: &'a [Cow<'a, Change>],
dep_arena: &mut super::arena::DepsArena,
peer_register: &mut ValueRegister<u64>,
push_op: &mut impl FnMut(TempOp<'a>),
@ -1396,7 +1396,7 @@ mod value {
False,
DeleteOnce,
ContainerIdx(usize),
I32(i32),
I64(i64),
F64(f64),
Str(&'a str),
DeleteSeq(i32),
@ -1463,7 +1463,7 @@ mod value {
True = 1,
False = 2,
DeleteOnce = 3,
I32 = 4,
I64 = 4,
ContainerType = 5,
F64 = 6,
Str = 7,
@ -1489,8 +1489,8 @@ mod value {
Some(ValueKind::False)
} else if n == ValueKind::DeleteOnce as u8 {
Some(ValueKind::DeleteOnce)
} else if n == ValueKind::I32 as u8 {
Some(ValueKind::I32)
} else if n == ValueKind::I64 as u8 {
Some(ValueKind::I64)
} else if n == ValueKind::ContainerType as u8 {
Some(ValueKind::ContainerType)
} else if n == ValueKind::F64 as u8 {
@ -1536,7 +1536,7 @@ mod value {
ValueKind::True => ValueKind::True as i64,
ValueKind::False => ValueKind::False as i64,
ValueKind::DeleteOnce => ValueKind::DeleteOnce as i64,
ValueKind::I32 => ValueKind::I32 as i64,
ValueKind::I64 => ValueKind::I64 as i64,
ValueKind::ContainerType => ValueKind::ContainerType as i64,
ValueKind::F64 => ValueKind::F64 as i64,
ValueKind::Str => ValueKind::Str as i64,
@ -1563,7 +1563,7 @@ mod value {
ValueKind::True => ValueKind::True as u8,
ValueKind::False => ValueKind::False as u8,
ValueKind::DeleteOnce => ValueKind::DeleteOnce as u8,
ValueKind::I32 => ValueKind::I32 as u8,
ValueKind::I64 => ValueKind::I64 as u8,
ValueKind::ContainerType => ValueKind::ContainerType as u8,
ValueKind::F64 => ValueKind::F64 as u8,
ValueKind::Str => ValueKind::Str as u8,
@ -1586,7 +1586,7 @@ mod value {
Value::True => ValueKind::True,
Value::False => ValueKind::False,
Value::DeleteOnce => ValueKind::DeleteOnce,
Value::I32(_) => ValueKind::I32,
Value::I64(_) => ValueKind::I64,
Value::ContainerIdx(_) => ValueKind::ContainerType,
Value::F64(_) => ValueKind::F64,
Value::Str(_) => ValueKind::Str,
@ -1607,7 +1607,7 @@ mod value {
LoroValue::Null => ValueKind::Null,
LoroValue::Bool(true) => ValueKind::True,
LoroValue::Bool(false) => ValueKind::False,
LoroValue::I32(_) => ValueKind::I32,
LoroValue::I64(_) => ValueKind::I64,
LoroValue::Double(_) => ValueKind::F64,
LoroValue::String(_) => ValueKind::Str,
LoroValue::List(_) => ValueKind::Array,
@ -1646,9 +1646,9 @@ mod value {
LoroValue::Null => ValueKind::Null,
LoroValue::Bool(true) => ValueKind::True,
LoroValue::Bool(false) => ValueKind::False,
LoroValue::I32(value) => {
self.write_i32(*value);
ValueKind::I32
LoroValue::I64(value) => {
self.write_i64(*value);
ValueKind::I64
}
LoroValue::Double(value) => {
self.write_f64(*value);
@ -1696,7 +1696,7 @@ mod value {
Value::True => {}
Value::False => {}
Value::DeleteOnce => {}
Value::I32(value) => self.write_i32(*value),
Value::I64(value) => self.write_i64(*value),
Value::F64(value) => self.write_f64(*value),
Value::Str(value) => self.write_str(value),
Value::DeleteSeq(value) => self.write_i32(*value),
@ -1711,6 +1711,10 @@ mod value {
}
}
fn write_i64(&mut self, value: i64) {
leb128::write::signed(&mut self.buffer, value).unwrap();
}
fn write_i32(&mut self, value: i32) {
leb128::write::signed(&mut self.buffer, value as i64).unwrap();
}
@ -1830,10 +1834,10 @@ mod value {
ValueKind::Null => LoroValue::Null,
ValueKind::True => LoroValue::Bool(true),
ValueKind::False => LoroValue::Bool(false),
ValueKind::I32 => LoroValue::I32(self.read_i32()?),
ValueKind::I64 => LoroValue::I64(self.read_i64()?),
ValueKind::F64 => LoroValue::Double(self.read_f64()?),
ValueKind::Str => LoroValue::String(Arc::new(self.read_str()?.to_owned())),
ValueKind::DeltaInt => LoroValue::I32(self.read_i32()?),
ValueKind::DeltaInt => LoroValue::I64(self.read_i64()?),
ValueKind::Array => {
let len = self.read_usize()?;
if len > MAX_COLLECTION_SIZE {
@ -1942,10 +1946,10 @@ mod value {
ValueKind::Null => LoroValue::Null,
ValueKind::True => LoroValue::Bool(true),
ValueKind::False => LoroValue::Bool(false),
ValueKind::I32 => LoroValue::I32(self.read_i32()?),
ValueKind::I64 => LoroValue::I64(self.read_i64()?),
ValueKind::F64 => LoroValue::Double(self.read_f64()?),
ValueKind::Str => LoroValue::String(Arc::new(self.read_str()?.to_owned())),
ValueKind::DeltaInt => LoroValue::I32(self.read_i32()?),
ValueKind::DeltaInt => LoroValue::I64(self.read_i64()?),
ValueKind::Array => {
let len = self.read_usize()?;
if len > MAX_COLLECTION_SIZE {
@ -2065,6 +2069,10 @@ mod value {
unreachable!();
}
pub fn read_i64(&mut self) -> LoroResult<i64> {
leb128::read::signed(&mut self.raw).map_err(|_| LoroError::DecodeDataCorruptionError)
}
pub fn read_i32(&mut self) -> LoroResult<i32> {
leb128::read::signed(&mut self.raw)
.map(|x| x as i32)

4
crates/loro-internal/src/fuzz.rs
View file

@ -419,7 +419,7 @@ where
#[allow(clippy::redundant_clone)]
let mut actions_clone = actions.clone();
let action_ref: usize = (&mut actions_clone) as *mut _ as usize;
#[allow(clippy::blocks_in_if_conditions)]
#[allow(clippy::blocks_in_conditions)]
if std::panic::catch_unwind(|| {
// SAFETY: test
let f = unsafe { &*(f_ref as *const F) };
@ -448,7 +448,7 @@ where
let f_ref: usize = f_ref as usize;
let mut actions_clone = candidate.clone();
let action_ref: usize = (&mut actions_clone) as *mut _ as usize;
#[allow(clippy::blocks_in_if_conditions)]
#[allow(clippy::blocks_in_conditions)]
if std::panic::catch_unwind(|| {
// SAFETY: test
let f = unsafe { &*(f_ref as *const F) };

4
crates/loro-internal/src/fuzz/recursive_refactored.rs
View file

@ -270,7 +270,7 @@ impl From<FuzzValue> for LoroValue {
fn from(v: FuzzValue) -> Self {
match v {
FuzzValue::Null => LoroValue::Null,
FuzzValue::I32(i) => LoroValue::I32(i),
FuzzValue::I32(i) => LoroValue::I64(i as i64),
FuzzValue::Container(_) => unreachable!(),
}
}
@ -815,7 +815,7 @@ pub fn normalize(site_num: u8, actions: &mut [Action]) -> Vec<Action> {
sites.preprocess(action);
applied.push(action.clone());
let sites_ptr: usize = &mut sites as *mut _ as usize;
#[allow(clippy::blocks_in_if_conditions)]
#[allow(clippy::blocks_in_conditions)]
if std::panic::catch_unwind(|| {
// SAFETY: Test
let sites = unsafe { &mut *(sites_ptr as *mut Vec<_>) };

4
crates/loro-internal/src/fuzz/richtext.rs
View file

@ -171,7 +171,7 @@ impl From<FuzzValue> for LoroValue {
fn from(v: FuzzValue) -> Self {
match v {
FuzzValue::Null => LoroValue::Null,
FuzzValue::I32(i) => LoroValue::I32(i),
FuzzValue::I32(i) => LoroValue::I64(i as i64),
FuzzValue::Container(_) => unreachable!(),
}
}
@ -477,7 +477,7 @@ pub fn normalize(site_num: u8, actions: &mut [Action]) -> Vec<Action> {
sites.preprocess(action);
applied.push(action.clone());
let sites_ptr: usize = &mut sites as *mut _ as usize;
#[allow(clippy::blocks_in_if_conditions)]
#[allow(clippy::blocks_in_conditions)]
if std::panic::catch_unwind(|| {
// SAFETY: Test
let sites = unsafe { &mut *(sites_ptr as *mut Vec<_>) };

4
crates/loro-internal/src/fuzz/tree.rs
View file

@ -207,7 +207,7 @@ impl From<FuzzValue> for LoroValue {
fn from(v: FuzzValue) -> Self {
match v {
FuzzValue::Null => LoroValue::Null,
FuzzValue::I32(i) => LoroValue::I32(i),
FuzzValue::I32(i) => LoroValue::I64(i as i64),
FuzzValue::Container(_) => unreachable!(),
}
}
@ -734,7 +734,7 @@ pub fn normalize(site_num: u8, actions: &mut [Action]) -> Vec<Action> {
sites.preprocess(action);
applied.push(action.clone());
let sites_ptr: usize = &mut sites as *mut _ as usize;
#[allow(clippy::blocks_in_if_conditions)]
#[allow(clippy::blocks_in_conditions)]
if std::panic::catch_unwind(|| {
// SAFETY: Test
let sites = unsafe { &mut *(sites_ptr as *mut Vec<_>) };

2
crates/loro-wasm/src/convert.rs
View file

@ -169,7 +169,7 @@ pub fn convert(value: LoroValue) -> JsValue {
LoroValue::Null => JsValue::NULL,
LoroValue::Bool(b) => JsValue::from_bool(b),
LoroValue::Double(f) => JsValue::from_f64(f),
LoroValue::I32(i) => JsValue::from_f64(i as f64),
LoroValue::I64(i) => JsValue::from_f64(i as f64),
LoroValue::String(s) => JsValue::from_str(&s),
LoroValue::List(list) => {
let list = Arc::try_unwrap(list).unwrap_or_else(|m| (*m).clone());

2
crates/rle/src/rle_vec.rs
View file

@ -622,7 +622,7 @@ impl<A: Array> Deref for RleVecWithLen<A> {
}
}
pub fn slice_vec_by<T, F>(vec: &Vec<T>, index: F, start: usize, end: usize) -> Vec<T>
pub fn slice_vec_by<T, F>(vec: &[T], index: F, start: usize, end: usize) -> Vec<T>
where
F: Fn(&T) -> usize,
T: Sliceable + HasLength,