Mirrored_Repos/AppFlowy
1
0
Fork 0
mirror of https://github.com/AppFlowy-IO/AppFlowy.git synced 2024-08-30 18:12:39 +00:00
Code Issues Packages Projects Releases Wiki Activity

temp

Browse Source
This commit is contained in:
appflowy 2021-08-15 21:36:03 +08:00
parent aef5e54c3f
commit 0962d5cd0f
6 changed files with 48 additions and 48 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
rust-lib/flowy-ot/src/client/view/format_ext.rs
View File

@ -27,7 +27,7 @@ impl FormatExt for FormatLinkAtCaretPositionExt {
let mut iter = DeltaIter::new(delta); let mut iter = DeltaIter::new(delta);
iter.seek::<CharMetric>(interval.start); iter.seek::<CharMetric>(interval.start);
let (before, after) = (iter.next_op_with_len(interval.size()), iter.next()); let (before, after) = (iter.next_op_before(interval.size()), iter.next());
let mut start = interval.end; let mut start = interval.end;
let mut retain = 0; let mut retain = 0;
@ -74,7 +74,7 @@ impl FormatExt for ResolveBlockFormatExt {
let mut start = 0; let mut start = 0;
let end = interval.size(); let end = interval.size();
while start < end && iter.has_next() { while start < end && iter.has_next() {
let next_op = iter.next_op_with_len(end - start).unwrap(); let next_op = iter.next_op_before(end - start).unwrap();
match find_newline(next_op.get_data()) { match find_newline(next_op.get_data()) {
None => new_delta.retain(next_op.length(), Attributes::empty()), None => new_delta.retain(next_op.length(), Attributes::empty()),
Some(_) => { Some(_) => {
@ -121,7 +121,7 @@ impl FormatExt for ResolveInlineFormatExt {
let end = interval.size(); let end = interval.size();
while start < end && iter.has_next() { while start < end && iter.has_next() {
let next_op = iter.next_op_with_len(end - start).unwrap(); let next_op = iter.next_op_before(end - start).unwrap();
match find_newline(next_op.get_data()) { match find_newline(next_op.get_data()) {
None => new_delta.retain(next_op.length(), attribute.clone().into()), None => new_delta.retain(next_op.length(), attribute.clone().into()),
Some(_) => { Some(_) => {

2
rust-lib/flowy-ot/src/client/view/insert_ext.rs
View File

@ -106,7 +106,7 @@ impl InsertExt for PreserveInlineStylesExt {
} }
let mut iter = DeltaIter::new(delta); let mut iter = DeltaIter::new(delta);
let prev = iter.next_op_with_len(index)?; let prev = iter.next_op_before(index)?;
if prev.get_data().contains(NEW_LINE) { if prev.get_data().contains(NEW_LINE) {
return None; return None;
} }

58
rust-lib/flowy-ot/src/core/delta/cursor.rs
View File

@ -9,8 +9,8 @@ pub struct Cursor<'a> {
pub(crate) delta: &'a Delta, pub(crate) delta: &'a Delta,
pub(crate) origin_iv: Interval, pub(crate) origin_iv: Interval,
pub(crate) next_iv: Interval, pub(crate) next_iv: Interval,
pub(crate) c_index: usize, pub(crate) iter_char_count: usize,
pub(crate) o_index: usize, pub(crate) iter_op_index: usize,
iter: Enumerate<Iter<'a, Operation>>, iter: Enumerate<Iter<'a, Operation>>,
next_op: Option<Operation>, next_op: Option<Operation>,
} }
@ -22,8 +22,8 @@ impl<'a> Cursor<'a> {
delta, delta,
origin_iv: interval, origin_iv: interval,
next_iv: interval, next_iv: interval,
c_index: 0, iter_char_count: 0,
o_index: 0, iter_op_index: 0,
iter: delta.ops.iter().enumerate(), iter: delta.ops.iter().enumerate(),
next_op: None, next_op: None,
}; };
@ -31,9 +31,11 @@ impl<'a> Cursor<'a> {
cursor cursor
} }
pub fn next_interval(&self) -> Interval { self.next_op_interval_with_constraint(None) } pub fn next_iv(&self) -> Interval { self.next_op_iv_before(None) }
pub fn next_op_with_len(&mut self, force_len: Option<usize>) -> Option<Operation> { pub fn next_op(&mut self) -> Option<Operation> { self.next_op_before(None) }
pub fn next_op_before(&mut self, b_index: Option<usize>) -> Option<Operation> {
let mut find_op = None; let mut find_op = None;
let next_op = self.next_op.take(); let next_op = self.next_op.take();
let mut next_op = next_op.as_ref(); let mut next_op = next_op.as_ref();
@ -42,10 +44,10 @@ impl<'a> Cursor<'a> {
next_op = find_next_op(self); next_op = find_next_op(self);
} }
let old_c_index = self.c_index; let old_iter_char_count = self.iter_char_count;
while find_op.is_none() && next_op.is_some() { while find_op.is_none() && next_op.is_some() {
let op = next_op.take().unwrap(); let op = next_op.take().unwrap();
let interval = self.next_op_interval_with_constraint(force_len); let interval = self.next_op_iv_before(b_index);
if interval.is_empty() { if interval.is_empty() {
self.next_op = Some(op.clone()); self.next_op = Some(op.clone());
break; break;
@ -57,8 +59,8 @@ impl<'a> Cursor<'a> {
self.next_op = op.shrink(suffix); self.next_op = op.shrink(suffix);
} }
self.c_index += interval.end; self.iter_char_count += interval.end;
self.next_iv.start = self.c_index; self.next_iv.start = self.iter_char_count;
if find_op.is_none() { if find_op.is_none() {
next_op = find_next_op(self); next_op = find_next_op(self);
@ -66,33 +68,31 @@ impl<'a> Cursor<'a> {
} }
if find_op.is_some() { if find_op.is_some() {
let last = self.c_index - old_c_index; let last = self.iter_char_count - old_iter_char_count;
let force_len = force_len.unwrap_or(0); let force_len = b_index.unwrap_or(0);
if force_len > last { if force_len > last {
let len = force_len - last; let len = force_len - last;
return self.next_op_with_len(Some(len)); return self.next_op_before(Some(len));
} }
} }
return find_op; return find_op;
} }
pub fn next_op(&mut self) -> Option<Operation> { self.next_op_with_len(None) }
pub fn has_next(&self) -> bool { self.next_iter_op().is_some() } pub fn has_next(&self) -> bool { self.next_iter_op().is_some() }
fn descend(&mut self, index: usize) { fn descend(&mut self, index: usize) {
self.next_iv.start += index; self.next_iv.start += index;
if self.c_index >= self.next_iv.start { if self.iter_char_count >= self.next_iv.start {
return; return;
} }
while let Some((o_index, op)) = self.iter.next() { while let Some((o_index, op)) = self.iter.next() {
self.o_index = o_index; self.iter_op_index = o_index;
let start = self.c_index; let start = self.iter_char_count;
let end = start + op.length(); let end = start + op.length();
let intersect = Interval::new(start, end).intersect(self.next_iv); let intersect = Interval::new(start, end).intersect(self.next_iv);
if intersect.is_empty() { if intersect.is_empty() {
self.c_index += op.length(); self.iter_char_count += op.length();
} else { } else {
self.next_op = Some(op.clone()); self.next_op = Some(op.clone());
break; break;
@ -106,7 +106,7 @@ impl<'a> Cursor<'a> {
let mut offset = 0; let mut offset = 0;
for op in &self.delta.ops { for op in &self.delta.ops {
offset += op.length(); offset += op.length();
if offset > self.c_index { if offset > self.iter_char_count {
next_op = Some(op); next_op = Some(op);
break; break;
} }
@ -115,17 +115,17 @@ impl<'a> Cursor<'a> {
next_op next_op
} }
fn next_op_interval_with_constraint(&self, force_len: Option<usize>) -> Interval { fn next_op_iv_before(&self, b_index: Option<usize>) -> Interval {
let next_op = self.next_iter_op(); let next_op = self.next_iter_op();
if next_op.is_none() { if next_op.is_none() {
return Interval::new(0, 0); return Interval::new(0, 0);
} }
let op = next_op.unwrap(); let op = next_op.unwrap();
let start = self.c_index; let start = self.iter_char_count;
let end = match force_len { let end = match b_index {
None => self.c_index + op.length(), None => self.iter_char_count + op.length(),
Some(force_len) => self.c_index + min(force_len, op.length()), Some(b_index) => self.iter_char_count + min(b_index, op.length()),
}; };
let intersect = Interval::new(start, end).intersect(self.next_iv); let intersect = Interval::new(start, end).intersect(self.next_iv);
let interval = intersect.translate_neg(start); let interval = intersect.translate_neg(start);
@ -137,7 +137,7 @@ fn find_next_op<'a>(cursor: &mut Cursor<'a>) -> Option<&'a Operation> {
match cursor.iter.next() { match cursor.iter.next() {
None => None, None => None,
Some((o_index, op)) => { Some((o_index, op)) => {
cursor.o_index = o_index; cursor.iter_op_index = o_index;
Some(op) Some(op)
}, },
} }
@ -152,7 +152,7 @@ pub struct OpMetric {}
impl Metric for OpMetric { impl Metric for OpMetric {
fn seek(cursor: &mut Cursor, index: usize) -> SeekResult { fn seek(cursor: &mut Cursor, index: usize) -> SeekResult {
let _ = check_bound(cursor.o_index, index)?; let _ = check_bound(cursor.iter_op_index, index)?;
let mut temp_cursor = Cursor::new(cursor.delta, cursor.origin_iv); let mut temp_cursor = Cursor::new(cursor.delta, cursor.origin_iv);
let mut offset = 0; let mut offset = 0;
while let Some((_, op)) = temp_cursor.iter.next() { while let Some((_, op)) = temp_cursor.iter.next() {
@ -170,8 +170,8 @@ pub struct CharMetric {}
impl Metric for CharMetric { impl Metric for CharMetric {
fn seek(cursor: &mut Cursor, index: usize) -> SeekResult { fn seek(cursor: &mut Cursor, index: usize) -> SeekResult {
let _ = check_bound(cursor.c_index, index)?; let _ = check_bound(cursor.iter_char_count, index)?;
let _ = cursor.next_op_with_len(Some(index)); let _ = cursor.next_op_before(Some(index));
Ok(()) Ok(())
} }

4
rust-lib/flowy-ot/src/core/delta/delta.rs
View File

@ -168,11 +168,11 @@ impl Delta {
); );
let op = iter let op = iter
.next_op_with_len(length) .next_op_before(length)
.unwrap_or(OpBuilder::retain(length).build()); .unwrap_or(OpBuilder::retain(length).build());
let other_op = other_iter let other_op = other_iter
.next_op_with_len(length) .next_op_before(length)
.unwrap_or(OpBuilder::retain(length).build()); .unwrap_or(OpBuilder::retain(length).build());
debug_assert_eq!(op.length(), other_op.length()); debug_assert_eq!(op.length(), other_op.length());

6
rust-lib/flowy-ot/src/core/delta/iterator.rs
View File

@ -24,7 +24,7 @@ impl<'a> DeltaIter<'a> {
pub fn next_op(&mut self) -> Option<Operation> { self.cursor.next_op() } pub fn next_op(&mut self) -> Option<Operation> { self.cursor.next_op() }
pub fn next_op_len(&self) -> Option<usize> { pub fn next_op_len(&self) -> Option<usize> {
let interval = self.cursor.next_interval(); let interval = self.cursor.next_iv();
if interval.is_empty() { if interval.is_empty() {
None None
} else { } else {
@ -32,8 +32,8 @@ impl<'a> DeltaIter<'a> {
} }
} }
pub fn next_op_with_len(&mut self, length: usize) -> Option<Operation> { pub fn next_op_before(&mut self, index: usize) -> Option<Operation> {
self.cursor.next_op_with_len(Some(length)) self.cursor.next_op_before(Some(index))
} }
pub fn seek<M: Metric>(&mut self, index: usize) { pub fn seek<M: Metric>(&mut self, index: usize) {

20
rust-lib/flowy-ot/tests/op_test.rs
View File

@ -154,7 +154,7 @@ fn delta_get_ops_in_interval_7() {
let mut iter_2 = DeltaIter::new(&delta); let mut iter_2 = DeltaIter::new(&delta);
assert_eq!( assert_eq!(
iter_2.next_op_with_len(2).unwrap(), iter_2.next_op_before(2).unwrap(),
OpBuilder::insert("12").build() OpBuilder::insert("12").build()
); );
assert_eq!(iter_2.next_op().unwrap(), OpBuilder::insert("345").build()); assert_eq!(iter_2.next_op().unwrap(), OpBuilder::insert("345").build());
@ -181,7 +181,7 @@ fn delta_seek_2() {
let mut iter = DeltaIter::new(&delta); let mut iter = DeltaIter::new(&delta);
assert_eq!( assert_eq!(
iter.next_op_with_len(1).unwrap(), iter.next_op_before(1).unwrap(),
OpBuilder::insert("1").build() OpBuilder::insert("1").build()
); );
} }
@ -193,21 +193,21 @@ fn delta_seek_3() {
let mut iter = DeltaIter::new(&delta); let mut iter = DeltaIter::new(&delta);
assert_eq!( assert_eq!(
iter.next_op_with_len(2).unwrap(), iter.next_op_before(2).unwrap(),
OpBuilder::insert("12").build() OpBuilder::insert("12").build()
); );
assert_eq!( assert_eq!(
iter.next_op_with_len(2).unwrap(), iter.next_op_before(2).unwrap(),
OpBuilder::insert("34").build() OpBuilder::insert("34").build()
); );
assert_eq!( assert_eq!(
iter.next_op_with_len(2).unwrap(), iter.next_op_before(2).unwrap(),
OpBuilder::insert("5").build() OpBuilder::insert("5").build()
); );
assert_eq!(iter.next_op_with_len(1), None); assert_eq!(iter.next_op_before(1), None);
} }
#[test] #[test]
@ -218,7 +218,7 @@ fn delta_seek_4() {
let mut iter = DeltaIter::new(&delta); let mut iter = DeltaIter::new(&delta);
iter.seek::<CharMetric>(3); iter.seek::<CharMetric>(3);
assert_eq!( assert_eq!(
iter.next_op_with_len(2).unwrap(), iter.next_op_before(2).unwrap(),
OpBuilder::insert("45").build() OpBuilder::insert("45").build()
); );
} }
@ -238,7 +238,7 @@ fn delta_seek_5() {
iter.seek::<CharMetric>(0); iter.seek::<CharMetric>(0);
assert_eq!( assert_eq!(
iter.next_op_with_len(4).unwrap(), iter.next_op_before(4).unwrap(),
OpBuilder::insert("1234").attributes(attributes).build(), OpBuilder::insert("1234").attributes(attributes).build(),
); );
} }
@ -252,7 +252,7 @@ fn delta_next_op_len_test() {
iter.seek::<CharMetric>(3); iter.seek::<CharMetric>(3);
assert_eq!(iter.next_op_len().unwrap(), 2); assert_eq!(iter.next_op_len().unwrap(), 2);
assert_eq!( assert_eq!(
iter.next_op_with_len(1).unwrap(), iter.next_op_before(1).unwrap(),
OpBuilder::insert("4").build() OpBuilder::insert("4").build()
); );
assert_eq!(iter.next_op_len().unwrap(), 1); assert_eq!(iter.next_op_len().unwrap(), 1);
@ -267,7 +267,7 @@ fn delta_next_op_len_test2() {
assert_eq!(iter.next_op_len().unwrap(), 5); assert_eq!(iter.next_op_len().unwrap(), 5);
assert_eq!( assert_eq!(
iter.next_op_with_len(5).unwrap(), iter.next_op_before(5).unwrap(),
OpBuilder::insert("12345").build() OpBuilder::insert("12345").build()
); );
assert_eq!(iter.next_op_len(), None); assert_eq!(iter.next_op_len(), None);