Struct AboveExSet 

pub struct AboveExSet { /* private fields */ }

Implementations

impl AboveExSet

pub fn from<I: IntoIterator<Item = u64>>(max: u64, iter: I) -> Self

Creates a new instance from the highest contiguous event, and a sequence of extra events.

Examples

use threshold::*;

let above_exset = AboveExSet::from(0, vec![2, 4, 5]);
assert!(!above_exset.is_event(1));
assert!(above_exset.is_event(2));
assert!(!above_exset.is_event(3));
assert!(above_exset.is_event(4));
assert!(above_exset.is_event(5));
assert!(!above_exset.is_event(6));

pub fn missing_below(&self, ceil: u64) -> impl Iterator<Item = u64> + '_

Returns a set of events that: 1) are below ceil (not including ceil) and 2) are not part of AboveExSet.

Trait Implementations

impl Clone for AboveExSet

fn clone(&self) -> AboveExSet

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for AboveExSet

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

Formats the value using the given formatter.

impl Default for AboveExSet

fn default() -> AboveExSet

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for AboveExSet

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl EventSet for AboveExSet

fn new() -> Self

Returns a new AboveExSet instance.

fn next_event(&mut self) -> u64

Generates the next event. There should be no extras when calling this.

Examples

use threshold::*;

let mut above_exset = AboveExSet::new();
assert_eq!(above_exset.next_event(), 1);
assert_eq!(above_exset.next_event(), 2);

fn add_event(&mut self, event: u64) -> bool

Adds an event to the set. Returns true if it’s a new event.

Examples

use threshold::*;

let mut above_exset = AboveExSet::new();

above_exset.add_event(1);
assert!(above_exset.is_event(1));
assert!(!above_exset.is_event(2));

above_exset.add_event(3);
assert!(above_exset.is_event(1));
assert!(!above_exset.is_event(2));
assert!(above_exset.is_event(3));

above_exset.add_event(2);
assert!(above_exset.is_event(1));
assert!(above_exset.is_event(2));
assert!(above_exset.is_event(3));

fn add_event_range(&mut self, start: u64, end: u64) -> bool

Adds a range of events to the set.

fn is_event(&self, event: u64) -> bool

Checks if an event is part of the set.

Examples

use threshold::*;

let mut above_exset = AboveExSet::new();
let event = above_exset.next_event();
assert!(above_exset.is_event(event));

above_exset.add_event(3);
assert!(!above_exset.is_event(2));
assert!(above_exset.is_event(3));

fn events(&self) -> (u64, Vec<u64>)

Returns all events seen as a tuple. The first component is the highest event seen, while the second is a vector with the exceptions (in no specific order).

Examples

use threshold::*;

let mut above_exset = AboveExSet::new();

above_exset.add_event(1);
assert_eq!(above_exset.events(), (1, vec![]));

above_exset.add_event(3);
assert_eq!(above_exset.events(), (1, vec![3]));

above_exset.add_event(2);
assert_eq!(above_exset.events(), (3, vec![]));

above_exset.add_event(4);
assert_eq!(above_exset.events(), (4, vec![]));

above_exset.add_event(6);
assert_eq!(above_exset.events(), (4, vec![6]));

fn frontier(&self) -> u64

Returns the frontier (the highest contiguous event seen).

Examples

use threshold::*;

let mut above_exset = AboveExSet::new();
assert_eq!(above_exset.frontier(), 0);

above_exset.add_event(1);
assert_eq!(above_exset.frontier(), 1);

above_exset.add_event(3);
assert_eq!(above_exset.frontier(), 1);

above_exset.add_event(2);
assert_eq!(above_exset.frontier(), 3);

above_exset.add_event(4);
assert_eq!(above_exset.frontier(), 4);

above_exset.add_event(6);
assert_eq!(above_exset.frontier(), 4);

fn join(&mut self, other: &Self)

Merges other AboveExSet into self.

Examples

use threshold::*;

let mut above_exset = AboveExSet::new();
above_exset.add_event(1);
above_exset.add_event(3);
above_exset.add_event(4);
assert_eq!(above_exset.events(), (1, vec![3, 4]));

above_exset.join(&AboveExSet::from_event(3));
assert_eq!(above_exset.events(), (1, vec![3, 4]));

above_exset.join(&AboveExSet::from_event(5));
assert_eq!(above_exset.events(), (1, vec![3, 4, 5]));

let mut other = AboveExSet::new();
other.add_event(2);
other.add_event(7);
above_exset.join(&other);
assert_eq!(above_exset.events(), (5, vec![7]));

fn event_iter(self) -> Self::EventIter

Returns a AboveExSet event iterator with all events from lowest to highest.

Examples

use threshold::*;

let mut above_exset = AboveExSet::new();
above_exset.add_event(3);
above_exset.add_event(5);

let mut iter = above_exset.event_iter();
assert_eq!(iter.next(), Some(3));
assert_eq!(iter.next(), Some(5));
assert_eq!(iter.next(), None);

type EventIter = EventIter

fn meet(&mut self, other: &Self)

Intersects other EventSet with self.

fn subtracted(&self, other: &Self) -> Vec<u64>

Return a list of events that remain when other is subtracted from self.

fn from_event(event: u64) -> Self

Creates a new instance from event.

fn from_event_range(start: u64, end: u64) -> Self

Creates a new instance from a range of events.

fn from_events<I: IntoIterator<Item = u64>>(iter: I) -> Self

Creates a new instance from several events.

impl PartialEq for AboveExSet

fn eq(&self, other: &AboveExSet) -> 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 AboveExSet

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 AboveExSet

impl StructuralPartialEq for AboveExSet