Struct TimelineDiffMinimizer 

struct TimelineDiffMinimizer<'a, S, I> {
    store: &'a S,
    item_map: HashMap<String, I>,
    updated_item_ids: HashSet<String>,
}

A helper struct to minimize a list of VectorDiff.

This does not support VectorDiff::Clear, VectorDiff::Truncate and VectorDiff::Reset as we assume that lists including those cannot be minimized in an optimal way.

Fields

store: &'a S

item_map: HashMap<String, I>

updated_item_ids: HashSet<String>

Implementations

impl<'a, S, I> TimelineDiffMinimizer<'a, S, I>

fn new(store: &'a S) -> Self

Construct a TimelineDiffMinimizer with the given store.

impl<S, I> TimelineDiffMinimizer<'_, S, I>

where S: TimelineDiffItemStore<Item = I>, I: TimelineDiffItem + Debug,

fn load_items(&mut self) -> Vec<String>

Load the items from the store.

Returns the list of timeline IDs of the items.

fn update_or_create_item(&mut self, data: &S::Data) -> String

Update or create an item in the store using the given data.

Returns the timeline ID of the item.

fn apply_diff_to_items( &mut self, item_ids: &[String], diff_list: Vec<VectorDiff<S::Data>>, ) -> Vec<String>

Apply the given diff to the given items.

fn item_diff_list( &self, old_item_ids: &[String], new_item_ids: &[String], ) -> Vec<TimelineDiff<S::Item>>

Compute the list of item diffs between the two given lists.

Uses a diff algorithm to minimize the removals and additions.

fn per_item_diff<'a>( old_item_ids: &'a [String], new_item_ids: &'a [String], ) -> Vec<ItemDiff<'a>>

Get a per-item diff by implementing a simple longest common subsequence (LCS) algorithm to find the minimal diff. Given that the list should not be too long, we do not need an efficient and more complicated algorithm.

Source: https://en.wikipedia.org/wiki/Longest_common_subsequence

fn apply(self, diff_list: Vec<VectorDiff<S::Data>>)

Minimize the given diff and apply it to the store.