Struct Frontier 

pub struct Frontier(pub SmallVec<LV, 2>);

A LocalFrontier is a set of local Time values which point at the set of changes with no children at this point in time. When there’s a single writer this will always just be the last local version we’ve seen.

The start of time is named with an empty list.

A frontier must always remain sorted (in numerical order). Note: This is not checked when deserializing via serde!

Tuple Fields

0: SmallVec<LV, 2>

Implementations

impl Frontier

pub fn root() -> Self

pub fn new_1(v: LV) -> Self

pub fn from_unsorted(data: &[LV]) -> Self

pub fn from_unsorted_iter<I: Iterator<Item = LV>>(iter: I) -> Self

pub fn from_sorted(data: &[LV]) -> Self

pub fn len(&self) -> usize

Frontiers should always be sorted smallest to largest.

pub fn is_root(&self) -> bool

pub fn is_empty(&self) -> bool

pub fn iter(&self) -> Iter<'_, usize>

pub fn try_get_single_entry(&self) -> Option<LV>

pub fn try_get_single_entry_mut(&mut self) -> Option<&mut LV>

pub fn replace(&mut self, with: &'_ [LV])

pub fn debug_check_sorted(&self)

pub fn advance(&mut self, graph: &Graph, range: DTRange)

Advance a frontier by the set of time spans in range

pub fn advance_sparse_known_run( &mut self, graph: &Graph, parents: &[LV], range: DTRange, )

Just like advance_by_known_run, the range MUST be in a single transaction in the graph.

pub fn advance_sparse(&mut self, graph: &Graph, range: DTRange)

advance_sparse is used for “sparse” causal graphs, which contain versions for other CRDTs and things. In this case, range might not directly follow the current frontier.

I think this function is equivalent to finding the dominators of self + all txns in range.

pub fn advance_by_known_run(&mut self, parents: &[LV], span: DTRange)

Advance branch frontier by a transaction.

This is ONLY VALID if the range is entirely within a txn.

pub fn merge_union(&mut self, other: &[LV], graph: &Graph)

Replaces self with dominators(self, other).

pub fn retreat(&mut self, graph: &Graph, range: DTRange)

pub fn insert(&mut self, new_item: LV)

pub fn replace_with_1(&mut self, new_val: LV)

Trait Implementations

impl AsRef<[usize]> for Frontier

fn as_ref(&self) -> &[LV]

Converts this type into a shared reference of the (usually inferred) input type.

impl Clone for Frontier

fn clone(&self) -> Frontier

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Frontier

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Frontier

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Frontier

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'a> From<&'a [usize]> for Frontier

fn from(f: &'a [LV]) -> Self

Converts to this type from the input type.

impl From<SmallVec<usize, 2>> for Frontier

fn from(f: SmallVec<LV, 2>) -> Self

Converts to this type from the input type.

impl From<usize> for Frontier

fn from(v: LV) -> Self

Converts to this type from the input type.

impl FromIterator<usize> for Frontier

fn from_iter<T: IntoIterator<Item = LV>>(iter: T) -> Self

Creates a value from an iterator.

impl Index<usize> for Frontier

type Output = usize

The returned type after indexing.

fn index(&self, index: usize) -> &Self::Output

Performs the indexing (container[index]) operation.

impl IndexMut<usize> for Frontier

fn index_mut(&mut self, index: usize) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl IntoIterator for Frontier

type Item = usize

The type of the elements being iterated over.

type IntoIter = <SmallVec<usize, 2> as IntoIterator>::IntoIter

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl PartialEq for Frontier

fn eq(&self, other: &Frontier) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Frontier

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for Frontier

impl StructuralPartialEq for Frontier