Trait libafl::state::UsesState

pub trait UsesState: UsesInput<Input = <Self::State as UsesInput>::Input> {
    type State: UsesInput;
}

Structs which implement this trait are aware of the state. This is used for type enforcement.

Required Associated Types

type State: UsesInput

The state known by this type.

Implementors

impl<'a, CS> UsesState for CoverageAccountingScheduler<'a, CS>where
    CS: UsesState,
    CS::State: Debug,

type State = <CS as UsesState>::State

impl<A, B> UsesState for CombinedExecutor<A, B>where
    A: UsesState,

type State = <A as UsesState>::State

impl<A, B, OTA, OTB, DOT> UsesState for DiffExecutor<A, B, OTA, OTB, DOT>where
    A: UsesState,
    B: UsesState<State = A::State>,

type State = <A as UsesState>::State

impl<CB, E, EM, Z> UsesState for ClosureStage<CB, E, EM, Z>where
    CB: FnMut(&mut Z, &mut E, &mut E::State, &mut EM, CorpusId) -> Result<(), Error>,
    E: UsesState,

type State = <E as UsesState>::State

impl<CB, E, EM, Z> UsesState for SyncFromDiskStage<CB, E, EM, Z>where
    E: UsesState,

type State = <E as UsesState>::State

impl<CB, EM, Z> UsesState for DumpToDiskStage<CB, EM, Z>where
    EM: UsesState,

type State = <EM as UsesState>::State

impl<CD, E, EM, ST, Z> UsesState for SkippableStage<CD, E, EM, ST, Z>where
    CD: FnMut(&mut ST::State) -> SkippableStageDecision,
    ST: Stage<E, EM, Z>,
    E: UsesState<State = ST::State>,
    EM: UsesState<State = ST::State>,
    Z: UsesState<State = ST::State>,

type State = <ST as UsesState>::State

impl<CS, E, EM, F1, F2, FF, M, OT, Z> UsesState for StdTMinMutationalStage<CS, E, EM, F1, F2, FF, M, OT, Z>where
    CS: Scheduler,
    M: Mutator<CS::Input, CS::State>,
    Z: ExecutionProcessor<OT, State = CS::State>,

type State = <CS as UsesState>::State

impl<CS, EM, OT, PS, Z> UsesState for PushStageAdapter<CS, EM, OT, PS, Z>where
    CS: UsesState,

type State = <CS as UsesState>::State

impl<CS, F, M> UsesState for MinimizerScheduler<CS, F, M>where
    CS: UsesState,

type State = <CS as UsesState>::State

impl<CS, F, OF, OT> UsesState for StdFuzzer<CS, F, OF, OT>where
    CS: Scheduler,
    F: Feedback<CS::State>,
    OF: Feedback<CS::State>,
    CS::State: HasClientPerfMonitor,

type State = <CS as UsesState>::State

impl<E> UsesState for TimeoutExecutor<E>where
    E: UsesState,

type State = <E as UsesState>::State

impl<E, EM, I, M, Z> UsesState for StdMutationalStage<E, EM, I, M, Z>where
    E: UsesState<State = Z::State>,
    EM: UsesState<State = Z::State>,
    M: Mutator<I, Z::State>,
    Z: Evaluator<E, EM>,
    Z::State: HasClientPerfMonitor + HasCorpus + HasRand,

type State = <Z as UsesState>::State

impl<E, EM, I, M, Z> UsesState for TuneableMutationalStage<E, EM, I, M, Z>where
    E: UsesState<State = Z::State>,
    EM: UsesState<State = Z::State>,
    M: Mutator<I, Z::State>,
    Z: Evaluator<E, EM>,
    Z::State: HasClientPerfMonitor + HasCorpus + HasRand,
    I: MutatedTransform<Z::Input, Z::State> + Clone,

type State = <Z as UsesState>::State

impl<E, EM, SOT, Z> UsesState for ShadowTracingStage<E, EM, SOT, Z>where
    E: UsesState,

type State = <E as UsesState>::State

impl<E, F, EM, I, M, O, Z> UsesState for PowerMutationalStage<E, F, EM, I, M, O, Z>where
    E: UsesState,

type State = <E as UsesState>::State

impl<E, OT> UsesState for WithObservers<E, OT>where
    E: UsesState,

type State = <E as UsesState>::State

impl<E, SOT> UsesState for ShadowExecutor<E, SOT>where
    E: UsesState,

type State = <E as UsesState>::State

impl<EM, O, OT, Z> UsesState for GeneralizationStage<EM, O, OT, Z>where
    EM: UsesState,
    EM::State: UsesInput<Input = BytesInput>,

type State = <EM as UsesState>::State

impl<EM, OT, S, T, Z> UsesState for CommandExecutor<EM, OT, S, T, Z>where
    S: UsesInput,

type State = S

impl<EM, TE, Z> UsesState for ConcolicTracingStage<EM, TE, Z>where
    TE: UsesState,

type State = <TE as UsesState>::State

impl<EM, TE, Z> UsesState for TracingStage<EM, TE, Z>where
    TE: UsesState,

type State = <TE as UsesState>::State

impl<F, S> UsesState for ProbabilitySamplingScheduler<F, S>where
    S: UsesInput,

type State = S

impl<F, S> UsesState for WeightedScheduler<F, S>where
    S: UsesInput,

type State = S

impl<H, HB, OT, S> UsesState for GenericInProcessExecutor<H, HB, OT, S>where
    H: ?Sized + FnMut(&S::Input) -> ExitKind,
    HB: BorrowMut<H>,
    OT: ObserversTuple<S>,
    S: UsesInput,

type State = S

impl<IC, ICB, DI, S, SP> UsesState for LlmpEventConverter<IC, ICB, DI, S, SP>where
    S: UsesInput,
    SP: ShMemProvider,
    IC: InputConverter<From = S::Input, To = DI>,
    ICB: InputConverter<From = DI, To = S::Input>,
    DI: Input,

type State = S

impl<IC, ICB, DI, S, SP> UsesState for SyncFromBrokerStage<IC, ICB, DI, S, SP>where
    SP: ShMemProvider + 'static,
    S: UsesInput,
    IC: InputConverter<From = S::Input, To = DI>,
    ICB: InputConverter<From = DI, To = S::Input>,
    DI: Input,

type State = S

impl<MT, S> UsesState for SimpleEventManager<MT, S>where
    S: UsesInput,

type State = S

impl<MT, S, SP> UsesState for SimpleRestartingEventManager<MT, S, SP>where
    S: UsesInput,
    SP: ShMemProvider,

type State = S

impl<O, OT, S> UsesState for CalibrationStage<O, OT, S>where
    S: UsesInput,

type State = S

impl<S> UsesState for NopEventManager<S>where
    S: UsesInput,

type State = S

impl<S> UsesState for PowerQueueScheduler<S>where
    S: UsesInput,

type State = S

impl<S> UsesState for QueueScheduler<S>where
    S: UsesInput,

type State = S

impl<S> UsesState for RandScheduler<S>where
    S: UsesInput,

type State = S

impl<S> UsesState for TuneableScheduler<S>where
    S: UsesInput,

type State = S

impl<S, SP> UsesState for LlmpEventManager<S, SP>where
    S: UsesInput,
    SP: ShMemProvider,

type State = S

impl<S, SP> UsesState for LlmpRestartingEventManager<S, SP>where
    S: UsesInput,
    SP: ShMemProvider + 'static,

type State = S