Struct timely::progress::frontier::MutableAntichain

pub struct MutableAntichain<T: PartialOrder + Ord> { /* fields omitted */ }

An antichain based on a multiset whose elements frequencies can be updated.

The MutableAntichain maintains frequencies for many elements of type T, and exposes the set of elements with positive count not greater than any other elements with positive count. The antichain may both advance and retreat; the changes do not all need to be to elements greater or equal to some elements of the frontier.

The type T must implement PartialOrder as well as Ord. The implementation of the Ord trait is used to efficiently organize the updates for cancellation, and to efficiently determine the lower bounds, and only needs to not contradict the PartialOrder implementation (that is, if PartialOrder orders two elements, then so does the Ord implementation).

The MutableAntichain implementation is done with the intent that updates to it are done in batches, and it is acceptable to rebuild the frontier from scratch when a batch of updates change it. This means that it can be expensive to maintain a large number of counts and change few elements near the frontier.

There is an update_dirty method for single updates that leave the MutableAntichain in a dirty state, but I strongly recommend against using them unless you must (on part of timely progress tracking seems to be greatly simplified by access to this)

Implementations

impl<T: PartialOrder + Ord + Clone> MutableAntichain<T>

pub fn new() -> MutableAntichain<T>

Creates a new empty MutableAntichain.

Examples

 use timely::progress::frontier::MutableAntichain;

 let frontier = MutableAntichain::<usize>::new();
 assert!(frontier.is_empty());

pub fn clear(&mut self)

Removes all elements.

Examples

 use timely::progress::frontier::MutableAntichain;

 let mut frontier = MutableAntichain::<usize>::new();
 frontier.clear();
 assert!(frontier.is_empty());

pub fn empty(&mut self)

This method deletes the contents. Unlike clear it records doing so.

pub fn frontier(&self) -> AntichainRef<'_, T>

Reveals the minimal elements with positive count.

Examples

 use timely::progress::frontier::MutableAntichain;

 let mut frontier = MutableAntichain::<usize>::new();
 assert!(frontier.frontier().len() == 0);

pub fn new_bottom(bottom: T) -> MutableAntichain<T>

Creates a new singleton MutableAntichain.

Examples

 use timely::progress::frontier::{AntichainRef, MutableAntichain};

 let mut frontier = MutableAntichain::new_bottom(0u64);
 assert!(frontier.frontier() == AntichainRef::new(&[0u64]));

pub fn is_empty(&self) -> bool

Returns true if there are no elements in the MutableAntichain.

Examples

 use timely::progress::frontier::MutableAntichain;

 let mut frontier = MutableAntichain::<usize>::new();
 assert!(frontier.is_empty());

pub fn less_than(&self, time: &T) -> bool

Returns true if any item in the MutableAntichain is strictly less than the argument.

Examples

 use timely::progress::frontier::MutableAntichain;

 let mut frontier = MutableAntichain::new_bottom(1u64);
 assert!(!frontier.less_than(&0));
 assert!(!frontier.less_than(&1));
 assert!(frontier.less_than(&2));

pub fn less_equal(&self, time: &T) -> bool

Returns true if any item in the MutableAntichain is less than or equal to the argument.

Examples

 use timely::progress::frontier::MutableAntichain;

 let mut frontier = MutableAntichain::new_bottom(1u64);
 assert!(!frontier.less_equal(&0));
 assert!(frontier.less_equal(&1));
 assert!(frontier.less_equal(&2));

pub fn update_dirty(&mut self, time: T, delta: i64)

Allows a single-element push, but dirties the antichain and prevents inspection until cleaned.

At the moment inspection is prevented via panic, so best be careful (this should probably be fixed). It is very important if you want to use this method that very soon afterwards you call something akin to update_iter, perhaps with a None argument if you have no more data, as this method will tidy up the internal representation.

pub fn update_iter<'a, I>(&'a mut self, updates: I) -> Drain<'a, (T, i64)> where
    I: IntoIterator<Item = (T, i64)>, 

Applies updates to the antichain and enumerates any changes.

Examples

 use timely::progress::frontier::{AntichainRef, MutableAntichain};

 let mut frontier = MutableAntichain::new_bottom(1u64);
 let changes =
 frontier
     .update_iter(vec![(1, -1), (2, 7)])
     .collect::<Vec<_>>();

 assert!(frontier.frontier() == AntichainRef::new(&[2]));
 assert!(changes == vec![(1, -1), (2, 1)]);

pub fn count_for(&self, query_time: &T) -> i64

Reports the count for a queried time.

Trait Implementations

impl<T: PartialOrder + Ord> Abomonation for MutableAntichain<T> where
    Vec<(T, i64)>: Abomonation,
    T: Abomonation,
    Vec<T>: Abomonation,
    ChangeBatch<T>: Abomonation, 

unsafe fn entomb<W: Write>(&self, _write: &mut W) -> Result<()>

Write any additional information about &self beyond its binary representation.

fn extent(&self) -> usize

Reports the number of further bytes required to entomb self.

unsafe fn exhume<'a, 'b>(
    &'a mut self,
    bytes: &'b mut [u8]
) -> Option<&'b mut [u8]>

Recover any information for &mut self not evident from its binary representation.

impl<T: Clone + PartialOrder + Ord> Clone for MutableAntichain<T>

fn clone(&self) -> MutableAntichain<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug + PartialOrder + Ord> Debug for MutableAntichain<T>

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

Formats the value using the given formatter.

impl<'de, T: PartialOrder + Ord> Deserialize<'de> for MutableAntichain<T> where
    T: Deserialize<'de>, 

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl<T: PartialOrder + Ord> Serialize for MutableAntichain<T> where
    T: Serialize, 

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

Serialize this value into the given Serde serializer.