Struct checkers::Events

pub struct Events { /* fields omitted */ }

Collections of events.

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

Implementations

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::{Event::*, Request, Events, Region};
let mut events = Events::new();

let request = Request::without_backtrace(Region::new(10.into(), 10, 1));
events.push(Alloc(request));

assert!(matches!(&events[0], &Alloc(..)));

pub fn allocs(&self) -> usize

Count the number of allocations in this collection of events.

Examples

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

let request = Request::without_backtrace(Region::new(10.into(), 10, 1));
events.push(Alloc(request));

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::{Event::*, Request, Events, Region, Realloc};
let mut events = Events::new();

events.push(Realloc(Realloc::without_backtrace(
    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::{Event::*, Events, Region, Request};
let mut events = Events::new();

let request = Request::without_backtrace(Region::new(10.into(), 10, 1));
events.push(Free(request));

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::{Event::*, Events, Region, Request};
let mut events = Events::new();

let request = Request::without_backtrace(Region::new(0x10.into(), 0x10, 1));
events.push(Alloc(request));

let request = Request::without_backtrace(Region::new(0x20.into(), 0x10, 1));
events.push(Alloc(request));

let request = Request::without_backtrace(Region::new(0x10.into(), 0x10, 1));
events.push(Free(request));

assert_eq!(0x20, events.max_memory_used().unwrap());

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.