Struct checkers::Events

pub struct Events { /* fields omitted */ }

Collections of events.

We use a wrapper type to provide convenience methods for diagnostics.

Methods

impl Events

pub const fn new() -> Self

Construct a new collection of allocations.

pub fn len(&self) -> usize

Get the number of events in this collection.

pub fn is_empty(&self) -> bool

Test if collection is empty.

pub fn capacity(&self) -> usize

Access the capacity of the Events container.

pub fn reserve(&mut self, cap: usize)

Reserve extra capacity for the underlying storage.

pub fn as_slice(&self) -> &[Event]

Fetch all allocations as a slice.

pub fn as_slice_mut(&mut self) -> &mut [Event]

Fetch all allocations as a slice.

pub fn clear(&mut self)

Clear the collection of events.

pub fn push(&mut self, event: Event)

Push a single event into the collection of events.

Examples

use checkers::{Events, Event, Region};
let mut events = Events::new();
let event = Event::Alloc(Region::new(10.into(), 10, 1));
events.push(event);
assert_eq!(event, events[0]);

pub fn allocs(&self) -> usize

Count the number of allocations in this collection of events.

Examples

use checkers::{Events, Event, Region};
let mut events = Events::new();
events.push(Event::Alloc(Region::new(10.into(), 10, 1)));
assert_eq!(1, events.allocs());
assert_eq!(0, events.frees());

pub fn reallocs(&self) -> usize

Count the number of allocations in this collection of events.

Examples

use checkers::{Events, Event, Region, Realloc};
let mut events = Events::new();

events.push(Event::Realloc(Realloc::new(
    Some(true),
    Region::new(10.into(), 10, 1),
    Region::new(20.into(), 10, 1)
)));

assert_eq!(1, events.reallocs());
assert_eq!(0, events.allocs());
assert_eq!(0, events.frees());

pub fn frees(&self) -> usize

Count the number of frees in this collection of events.

Examples

use checkers::{Events, Event, Region};
let mut events = Events::new();
events.push(Event::Free(Region::new(10.into(), 10, 1)));
assert_eq!(0, events.allocs());
assert_eq!(1, events.frees());

pub fn validate(&self, errors: &mut Vec<Violation>)

Validate the current state and populate the errors collection with any violations found.

See Machine::push for more details on the kind of validation errors that can be raised.

pub fn max_memory_used(&self) -> Result<usize, Violation>

Max amount of memory used according to this event history.

Returns the first violation encountered if the history is not sound.

Examples

use checkers::{Events, Event, Region};
let mut events = Events::new();
events.push(Event::Alloc(Region::new(0x10.into(), 0x10, 1)));
events.push(Event::Alloc(Region::new(0x20.into(), 0x10, 1)));
events.push(Event::Free(Region::new(0x10.into(), 0x10, 1)));
assert_eq!(Ok(0x20), events.max_memory_used());

Trait Implementations

impl Clone for Events

fn clone(&self) -> Events

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Events

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

Formats the value using the given formatter.

impl Deref for Events

type Target = [Event]

The resulting type after dereferencing.

fn deref(&self) -> &[Event]

Dereferences the value.

impl DerefMut for Events

fn deref_mut(&mut self) -> &mut [Event]

Mutably dereferences the value.

impl<I: SliceIndex<[Event]>> Index<I> for Events

type Output = I::Output

The returned type after indexing.

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

Performs the indexing (container[index]) operation.