Enum CoreEventSpace 

pub enum CoreEventSpace<'a> {
    NoteOn(&'a NoteOnEvent),
    NoteOff(&'a NoteOffEvent),
    NoteChoke(&'a NoteChokeEvent),
    NoteEnd(&'a NoteEndEvent),
    NoteExpression(&'a NoteExpressionEvent),
    ParamValue(&'a ParamValueEvent),
    ParamMod(&'a ParamModEvent),
    ParamGestureBegin(&'a ParamGestureBeginEvent),
    ParamGestureEnd(&'a ParamGestureEndEvent),
    Transport(&'a TransportEvent),
    Midi(&'a MidiEvent),
    Midi2(&'a Midi2Event),
    MidiSysEx(&'a MidiSysExEvent),
}

Core CLAP event set.

This enum represents the standard events defined in the CLAP specification (e.g. NoteOnEvent, ParamValueEvent).

It can be constructed from an UnknownEvent when the event is one of the core types.

Example

Converting from UnknownEvent to a CoreEventSpace:

use clack_common::events::UnknownEvent;
use clack_common::events::spaces::CoreEventSpace;

fn handle_event(event: &UnknownEvent) {
    if let Some(ev) = event.as_core_event() {
        match ev {
            CoreEventSpace::NoteOn(note) => { /* handle note‑on */ }
            CoreEventSpace::ParamValue(param) => { /* handle param change */ }
            _ => {}
        }
    }
}

Variants

NoteOn(&'a NoteOnEvent)

A note-on event (key press / attack)

NoteOff(&'a NoteOffEvent)

A note-off event (key release)

NoteChoke(&'a NoteChokeEvent)

A note choke (forcibly ends a note)

NoteEnd(&'a NoteEndEvent)

A note end (natural end of note)

NoteExpression(&'a NoteExpressionEvent)

A note expression change (e.g. per-note pitch)

ParamValue(&'a ParamValueEvent)

A parameter value change

ParamMod(&'a ParamModEvent)

A parameter modulation change

ParamGestureBegin(&'a ParamGestureBeginEvent)

Begin of a gesture (automation touch)

ParamGestureEnd(&'a ParamGestureEndEvent)

End of a gesture (automation release)

Transport(&'a TransportEvent)

Transport info (playhead, tempo, etc.)

Midi(&'a MidiEvent)

MIDI 1.0 event

Midi2(&'a Midi2Event)

MIDI 2.0 event

MidiSysEx(&'a MidiSysExEvent)

MIDI SysEx event

Trait Implementations

impl<'a> Clone for CoreEventSpace<'a>

fn clone(&self) -> CoreEventSpace<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Copy for CoreEventSpace<'a>

impl Debug for CoreEventSpace<'_>

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

Formats the value using the given formatter.

impl<'a> EventSpace<'a> for CoreEventSpace<'a>

unsafe fn from_unknown(event: &'a UnknownEvent) -> Option<CoreEventSpace<'a>>

Attempts to reinterpret a raw UnknownEvent as one of the core event types.

Returns None if the event does not belong to this event space.

const NAME: &'static CStr = c""

The specified name of this event space.

fn as_unknown(&self) -> &'a UnknownEvent

Returns this event as a type-erased UnknownEvent.

impl<'a> PartialEq for CoreEventSpace<'a>

fn eq(&self, other: &CoreEventSpace<'a>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<'a> StructuralPartialEq for CoreEventSpace<'a>