[−][src]Trait threshold::EventSet

pub trait EventSet: Clone + Debug + Default {
    type EventIter: Iterator<Item = u64>;
    fn new() -> Self;

    fn next_event(&mut self) -> u64;

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

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

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

    fn frontier(&self) -> u64;

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

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

    fn event_iter(self) -> Self::EventIter;

    fn from_event(event: u64) -> Self { ... }

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

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

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

EventSet trait to be implemented by MaxSet, BelowExSet and AboveExSet.

Associated Types

type EventIter: Iterator<Item = u64>

Loading content...

Required methods

fn new() -> Self

Returns a new instance.

fn next_event(&mut self) -> u64

Generates the next event.

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

Adds an event to the set.

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

Checks if an event is part of the set.

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

Returns all events seen as a pair.

For MaxSet:

  • the first component is the highest event
  • the second component is empty

For BelowExSet:

  • the first component is the highest event
  • the second component is a set of exceptions

For AboveExSet:

  • the first component is the highest event in a contiguous sequence
  • the second component is a set of outstanding events

If we've seen events [1, 2, 3, 5, 6], this function returns in

  • MaxSet: (6, [])
  • BelowExSet: (6, [4])
  • AboveExSet: (3, [5, 6])

fn frontier(&self) -> u64

Returns the frontier (the highest contiguous event seen).

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

Merges other EventSet into self.

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

Intersects other EventSet with self.

fn event_iter(self) -> Self::EventIter

Returns an iterator containing all elements represented by this event set.

Loading content...

Provided methods

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.

Loading content...

Implementors

impl EventSet for AboveExSet[src]

type EventIter = EventIter

fn new() -> Self[src]

Returns a new AboveExSet instance.

fn next_event(&mut self) -> u64[src]

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[src]

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[src]

Adds a range of events to the set.

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

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>)[src]

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[src]

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)[src]

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[src]

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);

impl EventSet for AboveRangeSet[src]

type EventIter = EventIter

fn new() -> Self[src]

Returns a new AboveRangeSet instance.

fn next_event(&mut self) -> u64[src]

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

Examples

use threshold::*;

let mut above_range_set = AboveRangeSet::new();
assert_eq!(above_range_set.next_event(), 1);
assert_eq!(above_range_set.next_event(), 2);

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

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

Examples

use threshold::*;

let mut above_range_set = AboveRangeSet::new();

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

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

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

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

Adds a range of events to the set.

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

Checks if an event is part of the set.

Examples

use threshold::*;

let mut above_range_set = AboveRangeSet::new();
let event = above_range_set.next_event();
assert!(above_range_set.is_event(event));

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

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

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_range_set = AboveRangeSet::new();

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

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

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

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

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

fn frontier(&self) -> u64[src]

Returns the frontier (the highest contiguous event seen).

Examples

use threshold::*;

let mut above_range_set = AboveRangeSet::new();
assert_eq!(above_range_set.frontier(), 0);

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

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

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

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

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

fn join(&mut self, other: &Self)[src]

Merges other AboveRangeSet into self.

Examples

use threshold::*;

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

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

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

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

fn event_iter(self) -> Self::EventIter[src]

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

Examples

use threshold::*;

let mut above_range_set = AboveRangeSet::new();
above_range_set.add_event(3);
above_range_set.add_event(5);

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

impl EventSet for BelowExSet[src]

type EventIter = EventIter

fn new() -> Self[src]

Returns a new BelowExSet instance.

fn next_event(&mut self) -> u64[src]

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[src]

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[src]

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>)[src]

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[src]

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)[src]

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[src]

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);

impl EventSet for MaxSet[src]

type EventIter = EventIter

fn new() -> Self[src]

Returns a new MaxSet instance.

fn next_event(&mut self) -> u64[src]

Generates the next event.

Examples

use threshold::*;

let mut maxset = MaxSet::new();
assert_eq!(maxset.next_event(), 1);
assert_eq!(maxset.next_event(), 2);

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

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

Examples

use threshold::*;

let mut maxset = MaxSet::new();
assert!(!maxset.is_event(9));
assert!(!maxset.is_event(10));

maxset.add_event(10);
assert!(maxset.is_event(9));
assert!(maxset.is_event(10));

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

Adds a range of events to the set. Returns true if a new event was added.

In the case of MaxSet we have that:

  • add_event_range(start, end) == add_event(end)

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

Checks if an event is part of the set.

Examples

use threshold::*;

let mut maxset = MaxSet::new();
let event = maxset.next_event();
assert!(maxset.is_event(event));

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

Returns all events seen.

Examples

use threshold::*;

let mut maxset = MaxSet::new();
maxset.add_event(2);
maxset.add_event(4);
assert_eq!(maxset.events(), (4, vec![]));

fn frontier(&self) -> u64[src]

Returns the frontier (the highest contiguous event seen). For a MaxSet, this is not necessarily the highest contiguous event, but simply the highest event. For exact EventSet representations that will actually return the highest contiguous event, see AboveExSet and BelowExSet.

Examples

use threshold::*;

let mut maxset = MaxSet::new();
assert_eq!(maxset.frontier(), 0);

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

maxset.add_event(3);
assert_eq!(maxset.frontier(), 3);

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

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

maxset.add_event(6);
assert_eq!(maxset.frontier(), 6);

fn join(&mut self, other: &Self)[src]

Merges other MaxSet into self.

Examples

use threshold::*;

let mut maxset = MaxSet::from_event(10);
assert!(!maxset.is_event(20));

maxset.join(&MaxSet::from_event(20));
assert!(maxset.is_event(20));

fn meet(&mut self, other: &Self)[src]

Intersects other MaxSet with self.

Examples

use threshold::*;

let mut maxset = MaxSet::from_event(20);
assert!(maxset.is_event(20));

maxset.meet(&MaxSet::from_event(10));
assert!(!maxset.is_event(20));

fn event_iter(self) -> Self::EventIter[src]

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

Examples

use threshold::*;

let mut maxset = MaxSet::new();
maxset.add_event(3);

let mut iter = maxset.event_iter();
assert_eq!(iter.next(), Some(1));
assert_eq!(iter.next(), Some(2));
assert_eq!(iter.next(), Some(3));
assert_eq!(iter.next(), None);
Loading content...