Enum input_linux::EventMut

pub enum EventMut<'a> {
    Synchronize(&'a mut SynchronizeEvent),
    Key(&'a mut KeyEvent),
    Relative(&'a mut RelativeEvent),
    Absolute(&'a mut AbsoluteEvent),
    Switch(&'a mut SwitchEvent),
    Misc(&'a mut MiscEvent),
    Led(&'a mut LedEvent),
    Autorepeat(&'a mut AutorepeatEvent),
    Sound(&'a mut SoundEvent),
    UInput(&'a mut UInputEvent),
    Unknown(&'a mut InputEvent),
}

A mutable reference to an input event.

Variants

Synchronize(&'a mut SynchronizeEvent)

Key(&'a mut KeyEvent)

Relative(&'a mut RelativeEvent)

Absolute(&'a mut AbsoluteEvent)

Switch(&'a mut SwitchEvent)

Misc(&'a mut MiscEvent)

Led(&'a mut LedEvent)

Autorepeat(&'a mut AutorepeatEvent)

Sound(&'a mut SoundEvent)

UInput(&'a mut UInputEvent)

Unknown(&'a mut InputEvent)

Unknown event type.

Implementations

impl<'a> EventMut<'a>

pub fn new(event: &'a mut InputEvent) -> Result<Self, RangeError>

Wraps the generic InputEvent into a mutable event.

Trait Implementations

impl<'a> AsRef<InputEvent> for EventMut<'a>

fn as_ref(&self) -> &InputEvent

Converts this type into a shared reference of the (usually inferred) input type.

impl<'a> Debug for EventMut<'a>

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

Formats the value using the given formatter.

impl<'a> From<&'a EventMut<'a>> for &'a InputEvent

fn from(event: &'a EventMut<'a>) -> Self

Converts to this type from the input type.

impl<'a> From<&'a mut AbsoluteEvent> for EventMut<'a>

fn from(event: &'a mut AbsoluteEvent) -> Self

Converts to this type from the input type.

impl<'a> From<&'a mut AutorepeatEvent> for EventMut<'a>

fn from(event: &'a mut AutorepeatEvent) -> Self

Converts to this type from the input type.

impl<'a> From<&'a mut Event> for EventMut<'a>

fn from(event: &'a mut Event) -> Self

Converts to this type from the input type.

impl<'a> From<&'a mut KeyEvent> for EventMut<'a>

fn from(event: &'a mut KeyEvent) -> Self

Converts to this type from the input type.

impl<'a> From<&'a mut LedEvent> for EventMut<'a>

fn from(event: &'a mut LedEvent) -> Self

Converts to this type from the input type.

impl<'a> From<&'a mut MiscEvent> for EventMut<'a>

fn from(event: &'a mut MiscEvent) -> Self

Converts to this type from the input type.

impl<'a> From<&'a mut RelativeEvent> for EventMut<'a>

fn from(event: &'a mut RelativeEvent) -> Self

Converts to this type from the input type.

impl<'a> From<&'a mut SoundEvent> for EventMut<'a>

fn from(event: &'a mut SoundEvent) -> Self

Converts to this type from the input type.

impl<'a> From<&'a mut SwitchEvent> for EventMut<'a>

fn from(event: &'a mut SwitchEvent) -> Self

Converts to this type from the input type.

impl<'a> From<&'a mut SynchronizeEvent> for EventMut<'a>

fn from(event: &'a mut SynchronizeEvent) -> Self

Converts to this type from the input type.

impl<'a> From<&'a mut UInputEvent> for EventMut<'a>

fn from(event: &'a mut UInputEvent) -> Self

Converts to this type from the input type.

impl<'a> Hash for EventMut<'a>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'a> PartialEq<EventMut<'a>> for EventMut<'a>

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> Eq for EventMut<'a>

impl<'a> StructuralEq for EventMut<'a>

impl<'a> StructuralPartialEq for EventMut<'a>