Struct BelowExSet 

pub struct BelowExSet { /* private fields */ }

Implementations

impl BelowExSet

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

Creates a new instance from the highest event, and a sequence of exceptions.

Examples

use threshold::*;

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

Trait Implementations

impl Clone for BelowExSet

fn clone(&self) -> BelowExSet

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for BelowExSet

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

Formats the value using the given formatter.

impl Default for BelowExSet

fn default() -> BelowExSet

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for BelowExSet

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl EventSet for BelowExSet

fn new() -> Self

Returns a new BelowExSet instance.

fn next_event(&mut self) -> u64

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

Examples

use threshold::*;

let mut below_exset = BelowExSet::new();
assert_eq!(below_exset.next_event(), 1);
assert_eq!(below_exset.next_event(), 2);

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

Adds an event to the set.

Examples

use threshold::*;

let mut below_exset = BelowExSet::new();

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

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

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

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

Checks if an event is part of the set.

Examples

use threshold::*;

let mut below_exset = BelowExSet::new();
let event = below_exset.next_event();
assert!(below_exset.is_event(event));

below_exset.add_event(3);
assert!(!below_exset.is_event(2));
assert!(below_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 below_exset = BelowExSet::new();

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

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

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

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

below_exset.add_event(6);
assert_eq!(below_exset.events(), (6, vec![5]));

fn frontier(&self) -> u64

Returns the frontier (the highest contiguous event seen).

Note: this method’s implementation will sort all exceptions on each call, and with that, the performance will not be great. If this becomes a problem, we could cache the frontier (as in AboveExSet) so that it doesn’t have to be computed here on each call.

Examples

use threshold::*;

let mut below_exset = BelowExSet::new();
assert_eq!(below_exset.frontier(), 0);

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

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

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

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

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

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

Merges other BelowExSet into self.

Examples

use threshold::*;

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

below_exset.join(&BelowExSet::from_event(3));
assert_eq!(below_exset.events(), (4, vec![2]));

below_exset.join(&BelowExSet::from_event(5));
assert_eq!(below_exset.events(), (5, vec![2]));

let mut other = BelowExSet::new();
other.add_event(2);
other.add_event(7);
below_exset.join(&other);
assert_eq!(below_exset.events(), (7, vec![6]));

fn event_iter(self) -> Self::EventIter

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

Examples

use threshold::*;

let mut below_exset = BelowExSet::new();
below_exset.add_event(3);
below_exset.add_event(5);

let mut iter = below_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.

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

Adds a range of events to the set.

impl PartialEq for BelowExSet

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

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 BelowExSet

impl StructuralPartialEq for BelowExSet