mirrors/loro
1
0
Fork 0
mirror of https://github.com/loro-dev/loro.git synced 2025-02-05 20:17:13 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 2

refactor: rm unused code (#380)

Browse source
This commit is contained in:
Zixuan Chen 2024-06-07 10:17:23 +08:00 committed by GitHub
parent f86421ee75
commit d2973df859
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
1 changed files with 0 additions and 220 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

220
crates/loro-internal/src/version.rs
View file

@ -901,226 +901,6 @@ pub fn are_frontiers_eq(a: &[ID], b: &[ID]) -> bool {
a == b
}
#[derive(Debug, Default)]
pub struct PatchedVersionVector {
pub base: Arc<VersionVector>,
pub patch: VersionVector,
}
impl Clone for PatchedVersionVector {
fn clone(&self) -> Self {
Self {
base: Arc::clone(&self.base),
patch: self.patch.clone(),
}
}
}
impl From<PatchedVersionVector> for VersionVector {
fn from(mut v: PatchedVersionVector) -> Self {
for (client_id, counter) in v.base.iter() {
if v.patch.contains_key(client_id) {
continue;
}
v.patch.set_last(ID::new(*client_id, *counter));
}
v.patch
}
}
impl PatchedVersionVector {
#[inline]
pub fn new(base: Arc<VersionVector>) -> Self {
Self {
base,
patch: Default::default(),
}
}
#[inline]
pub fn is_empty(&self) -> bool {
self.patch.is_empty() && self.base.is_empty()
}
pub fn from_version(base: &Arc<VersionVector>, version: &VersionVector) -> Self {
let mut patch = VersionVector::new();
for (client_id, counter) in version.iter() {
if let Some(base_counter) = base.get(client_id) {
if *base_counter != *counter {
patch.set_end(ID::new(*client_id, *counter));
}
} else {
patch.set_end(ID::new(*client_id, *counter));
}
}
if cfg!(debug_assertions) {
for (client_id, counter) in base.iter() {
if let Some(patch_counter) = version.get(client_id) {
assert!(*patch_counter >= *counter);
} else {
unreachable!("base should be a subset of version");
}
}
}
Self {
base: Arc::clone(base),
patch,
}
}
#[inline]
pub fn extend_to_include_last_id(&mut self, id: ID) {
self.patch.extend_to_include_last_id(id);
self.omit_if_needless(id.peer);
}
#[inline]
pub fn set_end(&mut self, id: ID) {
self.patch.set_end(id);
self.omit_if_needless(id.peer);
}
#[inline]
pub fn set_last(&mut self, id: ID) {
self.patch.set_last(id);
self.omit_if_needless(id.peer);
}
#[inline]
pub fn extend_to_include(&mut self, span: IdSpan) {
self.patch.extend_to_include(span);
self.omit_if_needless(span.peer);
}
#[inline]
pub fn shrink_to_exclude(&mut self, span: IdSpan) {
self.patch.shrink_to_exclude(span);
self.omit_if_needless(span.peer);
}
#[inline]
pub fn forward(&mut self, spans: &IdSpanVector) {
for span in spans.iter() {
let span = IdSpan {
peer: *span.0,
counter: *span.1,
};
if let Some(counter) = self.patch.get_mut(&span.peer) {
if *counter < span.counter.norm_end() {
*counter = span.counter.norm_end();
self.omit_if_needless(span.peer);
}
} else {
let target = span.counter.norm_end();
if self.base.get(&span.peer) == Some(&target) {
continue;
}
self.patch.insert(span.peer, target);
}
}
}
#[inline]
pub fn retreat(&mut self, spans: &IdSpanVector) {
for span in spans.iter() {
let span = IdSpan {
peer: *span.0,
counter: *span.1,
};
if let Some(counter) = self.patch.get_mut(&span.peer) {
if *counter > span.counter.min() {
*counter = span.counter.min();
self.omit_if_needless(span.peer);
}
}
}
}
#[inline(always)]
fn omit_if_needless(&mut self, client_id: PeerID) {
if let Some(patch_value) = self.patch.get(&client_id) {
if *patch_value == *self.base.get(&client_id).unwrap_or(&0) {
self.patch.remove(&client_id);
}
}
}
#[inline]
pub fn get(&self, client_id: &PeerID) -> Option<&Counter> {
self.patch
.get(client_id)
.or_else(|| self.base.get(client_id))
}
#[inline]
pub fn insert(&mut self, client_id: PeerID, counter: Counter) {
self.patch.insert(client_id, counter);
self.omit_if_needless(client_id);
}
#[inline]
pub fn includes_id(&self, id: ID) -> bool {
self.patch.includes_id(id) || self.base.includes_id(id)
}
pub fn iter(&self) -> impl Iterator<Item = (&PeerID, &Counter)> {
self.patch.iter().chain(
self.base
.iter()
.filter(|(client_id, _)| !self.patch.contains_key(client_id)),
)
}
pub fn sub_iter<'a>(&'a self, rhs: &'a Self) -> impl Iterator<Item = IdSpan> + 'a {
if !Arc::ptr_eq(&self.base, &rhs.base) {
unimplemented!();
}
self.patch.sub_iter(&rhs.patch)
}
pub fn diff_iter<'a>(
&'a self,
rhs: &'a Self,
) -> (
impl Iterator<Item = IdSpan> + 'a,
impl Iterator<Item = IdSpan> + 'a,
) {
if !Arc::ptr_eq(&self.base, &rhs.base) {
unimplemented!();
}
self.patch.diff_iter(&rhs.patch)
}
}
impl PartialEq for PatchedVersionVector {
fn eq(&self, other: &Self) -> bool {
if Arc::ptr_eq(&self.base, &other.base) {
self.patch.eq(&other.patch)
} else {
self.base == other.base && self.patch == other.patch
}
}
}
impl PartialOrd for PatchedVersionVector {
fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
if Arc::ptr_eq(&self.base, &other.base) || self.base == other.base {
self.patch.partial_cmp(&other.patch)
} else {
None
}
}
}
#[cfg(test)]
mod tests {
#![allow(clippy::neg_cmp_op_on_partial_ord)]