Enum Flow 

#[non_exhaustive]
pub enum Flow {
    Continue,
    Cancel,
}

Whether a mod claims a cancellable hook.

A mod still told once an earlier one cancelled marks its method #[listener(receive_cancelled)] and reads the event’s cancelled field, which it may set back to false:

use mod_api::{ClientHost, Flow, Hooks, RenderGuiPreEvent};
#[derive(Default)]
struct Gui;
#[mod_api::horizon_mod]
impl Hooks for Gui {
    #[listener(priority = -10, receive_cancelled)]
    fn render_gui_pre(&self, _: &dyn ClientHost, event: &mut RenderGuiPreEvent) -> Flow {
        event.cancelled = false;
        Flow::Continue
    }
}

A hook no mod can cancel has no cancel to receive, so the option doesn’t compile there:

use mod_api::{ClientHost, ClientTickPreEvent, Hooks};
#[derive(Default)]
struct Ticker;
#[mod_api::horizon_mod]
impl Hooks for Ticker {
    #[listener(receive_cancelled)]
    fn client_tick_pre(&self, _: &mut dyn ClientHost, _: &mut ClientTickPreEvent) {}
}

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Continue

Go on to the next listener and then the game’s own behaviour.

Cancel

Stop here; the game’s own behaviour does not run.

Trait Implementations

impl Clone for Flow

fn clone(&self) -> Flow

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Flow

impl Debug for Flow

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

Formats the value using the given formatter.

impl Eq for Flow

impl PartialEq for Flow

fn eq(&self, other: &Flow) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for Flow

impl Wire for Flow

const MIN: usize = 4usize

Minimum encoded size, used to reject impossible collection lengths.

fn put(&self, out: &mut Writer)

Encodes this value, recording failures on the writer.

fn put_owned(self, out: &mut Writer)

Consumes owned data when a resource’s ownership must cross the boundary.

fn take(input: &mut Reader<'_>) -> Result<Flow, WireError>

Decodes one value, leaving any following bytes for the caller.