Struct libafl::events::simple::SimpleEventManager

pub struct SimpleEventManager<I, S, ST> where
    I: Input,
    ST: Stats,  { /* fields omitted */ }

A simple, single-threaded event manager that just logs

Implementations

impl<I, S, ST> SimpleEventManager<I, S, ST> where
    I: Input,
    ST: Stats, 

pub fn new(stats: ST) -> Self

Creates a new SimpleEventManager.

Trait Implementations

impl<I: Clone, S: Clone, ST: Clone> Clone for SimpleEventManager<I, S, ST> where
    I: Input,
    ST: Stats, 

fn clone(&self) -> SimpleEventManager<I, S, ST>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<I: Debug, S: Debug, ST: Debug> Debug for SimpleEventManager<I, S, ST> where
    I: Input,
    ST: Stats, 

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

Formats the value using the given formatter.

impl<I, S, ST> EventManager<I, S> for SimpleEventManager<I, S, ST> where
    I: Input,
    ST: Stats, 

fn process<CS, E, OT>(
    &mut self,
    state: &mut S,
    _executor: &mut E,
    _scheduler: &CS
) -> Result<usize, Error> where
    CS: CorpusScheduler<I, S>,
    E: Executor<I> + HasObservers<OT>,
    OT: ObserversTuple, 

Fire an Event Lookup for incoming events and process them. Return the number of processes events or an error

fn fire(&mut self, _state: &mut S, event: Event<I>) -> Result<(), Error>

Send off an event to the broker

fn serialize_observers<OT>(&mut self, observers: &OT) -> Result<Vec<u8>, Error> where
    OT: ObserversTuple, 

Serialize all observers for this type and manager

fn deserialize_observers<OT>(
    &mut self,
    observers_buf: &[u8]
) -> Result<OT, Error> where
    OT: ObserversTuple, 

Deserialize all observers for this type and manager

fn on_restart(&mut self, _state: &mut S) -> Result<(), Error>

For restarting event managers, implement a way to forward state to their next peers.

fn await_restart_safe(&mut self)

Block until we are safe to exit.