Enum EventBody 

pub enum EventBody<'a> {
    Owned(EventBodyOwned),
    Borrowed(EventBodyBorrowed<'a>),
}

Common event body that can be either owned or borrowed.

This is useful for APIs that can return either owned or borrowed event bodies. Having this type allows to be generic over the event body type.

Variants

Owned(EventBodyOwned)

Borrowed(EventBodyBorrowed<'a>)

Implementations

impl<'a> EventBody<'_>

pub fn as_owned(&self) -> Result<EventBodyOwned, AtspiError>

Non-consuming conversion to an owned event body.

Does cloning.

Errors

The borrowed variant will error if the following conditions are met:

1. the any_data field contains an std::os::fd::OwnedFd type, and
2. the maximum number of open files for the process is exceeded.

pub fn into_owned(self) -> Result<EventBodyOwned, AtspiError>

Consuming conversion to an owned event body.

Does cloning.

Errors

The borrowed variant will error if the following conditions are met:

1. the any_data field contains an std::os::fd::OwnedFd type, and
2. the maximum number of open files for the process is exceeded.

pub fn kind(&'a self) -> &'a str

The kind field as &str.

With both variants, this method returns a reference to the kind field.

pub fn take_kind(&mut self) -> String

Take or convert the kind field as String.

With the owned variant, this method takes the kind field and replaces it with an empty string. With the borrowed variant, this method clones and allocates the kind field.

pub fn detail1(&self) -> i32

The detail1 field.

pub fn detail2(&self) -> i32

The detail2 field.

pub fn any_data(&'a self) -> &'a Value<'a>

The any_data field as &Value. With both variants, this method returns a reference to the any_data field.

pub fn take_any_data(&mut self) -> OwnedValue

Take or convert the any_data field as OwnedValue. With the owned variant, this method takes the any_data field and replaces it with a default value. As Value does not have a default value, we will replace with 0_u32, a nbon-allocating value.

With the borrowed variant, this method clones and allocates the any_data field.

Panics

This method will panic if the any_data field contains an std::os::fd::OwnedFd type, and the maximum number of open files for the process is exceeded.

None of the types in crate::events use std::os::fd::OwnedFd. Events on the AT-SPI bus could, theoretically send a file descriptor, but nothing in the current specification describes that.

Trait Implementations

impl<'a> Clone for EventBody<'a>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for EventBody<'a>

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

Formats the value using the given formatter.

impl Default for EventBody<'_>

fn default() -> EventBody<'_>

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for EventBody<'de>

fn deserialize<D>( deserializer: D, ) -> Result<EventBody<'de>, <D as Deserializer<'de>>::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<AbsEvent> for EventBody<'_>

fn from(event: AbsEvent) -> EventBody<'_>

Converts to this type from the input type.

impl From<ButtonEvent> for EventBody<'_>

fn from(event: ButtonEvent) -> EventBody<'_>

Converts to this type from the input type.

impl From<ChildrenChangedEvent> for EventBody<'_>

fn from(event: ChildrenChangedEvent) -> EventBody<'_>

Converts to this type from the input type.

impl From<EventBody<'_>> for EventBodyQtOwned

fn from(event: EventBody<'_>) -> EventBodyQtOwned

Converts to this type from the input type.

impl<'b> From<EventBodyBorrowed<'b>> for EventBody<'b>

fn from(borrowed: EventBodyBorrowed<'b>) -> EventBody<'b>

Converts to this type from the input type.

impl From<EventBodyOwned> for EventBody<'_>

fn from(owned: EventBodyOwned) -> EventBody<'_>

Converts to this type from the input type.

impl<'a> From<EventBodyQtBorrowed<'a>> for EventBody<'a>

fn from(qt_borrowed: EventBodyQtBorrowed<'a>) -> EventBody<'a>

Converts to this type from the input type.

impl From<EventBodyQtOwned> for EventBody<'_>

fn from(qt_owned: EventBodyQtOwned) -> EventBody<'_>

Converts to this type from the input type.

impl From<PropertyChangeEvent> for EventBody<'_>

fn from(event: PropertyChangeEvent) -> EventBody<'_>

Converts to this type from the input type.

impl From<RelEvent> for EventBody<'_>

fn from(event: RelEvent) -> EventBody<'_>

Converts to this type from the input type.

impl From<StateChangedEvent> for EventBody<'_>

fn from(event: StateChangedEvent) -> EventBody<'_>

Converts to this type from the input type.

impl<'msg> MessageConversionExt<'msg, EventBody<'msg>> for AbsEvent

fn try_from_message( msg: &'msg Message, header: &Header<'_>, ) -> Result<AbsEvent, AtspiError>

Convert a zbus::Message into this event type. Does all the validation for you.

fn validate_interface(header: &Header<'_>) -> Result<(), AtspiError>

Validate the interface string via zbus::message::Header::interface against Self’s assignment of DBusInterface::DBUS_INTERFACE

fn validate_member(hdr: &Header<'_>) -> Result<(), AtspiError>

Validate the member string via zbus::message::Header::member against Self’s assignment of DBusMember::DBUS_MEMBER

fn validate_body(msg: &Message) -> Result<(), AtspiError>

Validate the body signature against the zvariant::Signature of MessageConversion::Body

impl<'msg> MessageConversionExt<'msg, EventBody<'msg>> for ActivateEvent

fn try_from_message( msg: &'msg Message, header: &Header<'_>, ) -> Result<ActivateEvent, AtspiError>

Convert a zbus::Message into this event type. Does all the validation for you.

fn validate_interface(header: &Header<'_>) -> Result<(), AtspiError>

Validate the interface string via zbus::message::Header::interface against Self’s assignment of DBusInterface::DBUS_INTERFACE

fn validate_member(hdr: &Header<'_>) -> Result<(), AtspiError>

Validate the member string via zbus::message::Header::member against Self’s assignment of DBusMember::DBUS_MEMBER

fn validate_body(msg: &Message) -> Result<(), AtspiError>

Validate the body signature against the zvariant::Signature of MessageConversion::Body

impl<'msg> MessageConversionExt<'msg, EventBody<'msg>> for ActiveDescendantChangedEvent

fn try_from_message( msg: &'msg Message, header: &Header<'_>, ) -> Result<ActiveDescendantChangedEvent, AtspiError>

Convert a zbus::Message into this event type. Does all the validation for you.

fn validate_interface(header: &Header<'_>) -> Result<(), AtspiError>

Validate the interface string via zbus::message::Header::interface against Self’s assignment of DBusInterface::DBUS_INTERFACE

fn validate_member(hdr: &Header<'_>) -> Result<(), AtspiError>

Validate the member string via zbus::message::Header::member against Self’s assignment of DBusMember::DBUS_MEMBER

fn validate_body(msg: &Message) -> Result<(), AtspiError>

Validate the body signature against the zvariant::Signature of MessageConversion::Body

impl<'msg> MessageConversionExt<'msg, EventBody<'msg>> for AnnouncementEvent

fn try_from_message( msg: &'msg Message, header: &Header<'_>, ) -> Result<AnnouncementEvent, AtspiError>

Convert a zbus::Message into this event type. Does all the validation for you.

fn validate_interface(header: &Header<'_>) -> Result<(), AtspiError>

Validate the interface string via zbus::message::Header::interface against Self’s assignment of DBusInterface::DBUS_INTERFACE

fn validate_member(hdr: &Header<'_>) -> Result<(), AtspiError>

Validate the member string via zbus::message::Header::member against Self’s assignment of DBusMember::DBUS_MEMBER

fn validate_body(msg: &Message) -> Result<(), AtspiError>

Validate the body signature against the zvariant::Signature of MessageConversion::Body

impl<'msg> MessageConversionExt<'msg, EventBody<'msg>> for ApplicationChangedEvent

fn try_from_message( msg: &'msg Message, header: &Header<'_>, ) -> Result<ApplicationChangedEvent, AtspiError>

Convert a zbus::Message into this event type. Does all the validation for you.

fn validate_interface(header: &Header<'_>) -> Result<(), AtspiError>

Validate the interface string via zbus::message::Header::interface against Self’s assignment of DBusInterface::DBUS_INTERFACE

fn validate_member(hdr: &Header<'_>) -> Result<(), AtspiError>

Validate the member string via zbus::message::Header::member against Self’s assignment of DBusMember::DBUS_MEMBER

fn validate_body(msg: &Message) -> Result<(), AtspiError>

Validate the body signature against the zvariant::Signature of MessageConversion::Body

impl<'msg> MessageConversionExt<'msg, EventBody<'msg>> for AttributesChangedEvent

fn try_from_message( msg: &'msg Message, header: &Header<'_>, ) -> Result<AttributesChangedEvent, AtspiError>

Convert a zbus::Message into this event type. Does all the validation for you.

fn validate_interface(header: &Header<'_>) -> Result<(), AtspiError>

Validate the interface string via zbus::message::Header::interface against Self’s assignment of DBusInterface::DBUS_INTERFACE

fn validate_member(hdr: &Header<'_>) -> Result<(), AtspiError>

Validate the member string via zbus::message::Header::member against Self’s assignment of DBusMember::DBUS_MEMBER

fn validate_body(msg: &Message) -> Result<(), AtspiError>

Validate the body signature against the zvariant::Signature of MessageConversion::Body

impl<'msg> MessageConversionExt<'msg, EventBody<'msg>> for AttributesChangedEvent

fn try_from_message( msg: &'msg Message, header: &Header<'_>, ) -> Result<AttributesChangedEvent, AtspiError>

Convert a zbus::Message into this event type. Does all the validation for you.

fn validate_interface(header: &Header<'_>) -> Result<(), AtspiError>

Validate the interface string via zbus::message::Header::interface against Self’s assignment of DBusInterface::DBUS_INTERFACE

fn validate_member(hdr: &Header<'_>) -> Result<(), AtspiError>

Validate the member string via zbus::message::Header::member against Self’s assignment of DBusMember::DBUS_MEMBER

fn validate_body(msg: &Message) -> Result<(), AtspiError>

Validate the body signature against the zvariant::Signature of MessageConversion::Body

impl<'msg> MessageConversionExt<'msg, EventBody<'msg>> for BoundsChangedEvent

fn try_from_message( msg: &'msg Message, header: &Header<'_>, ) -> Result<BoundsChangedEvent, AtspiError>

Convert a zbus::Message into this event type. Does all the validation for you.

fn validate_interface(header: &Header<'_>) -> Result<(), AtspiError>

Validate the interface string via zbus::message::Header::interface against Self’s assignment of DBusInterface::DBUS_INTERFACE

fn validate_member(hdr: &Header<'_>) -> Result<(), AtspiError>

Validate the member string via zbus::message::Header::member against Self’s assignment of DBusMember::DBUS_MEMBER

fn validate_body(msg: &Message) -> Result<(), AtspiError>

Validate the body signature against the zvariant::Signature of MessageConversion::Body

impl<'msg> MessageConversionExt<'msg, EventBody<'msg>> for ButtonEvent

fn try_from_message( msg: &'msg Message, header: &Header<'_>, ) -> Result<ButtonEvent, AtspiError>

Convert a zbus::Message into this event type. Does all the validation for you.

fn validate_interface(header: &Header<'_>) -> Result<(), AtspiError>

Validate the interface string via zbus::message::Header::interface against Self’s assignment of DBusInterface::DBUS_INTERFACE

fn validate_member(hdr: &Header<'_>) -> Result<(), AtspiError>

Validate the member string via zbus::message::Header::member against Self’s assignment of DBusMember::DBUS_MEMBER

fn validate_body(msg: &Message) -> Result<(), AtspiError>

Validate the body signature against the zvariant::Signature of MessageConversion::Body

impl<'msg> MessageConversionExt<'msg, EventBody<'msg>> for CharWidthChangedEvent

fn try_from_message( msg: &'msg Message, header: &Header<'_>, ) -> Result<CharWidthChangedEvent, AtspiError>

Convert a zbus::Message into this event type. Does all the validation for you.

fn validate_interface(header: &Header<'_>) -> Result<(), AtspiError>

Validate the interface string via zbus::message::Header::interface against Self’s assignment of DBusInterface::DBUS_INTERFACE

fn validate_member(hdr: &Header<'_>) -> Result<(), AtspiError>

Validate the member string via zbus::message::Header::member against Self’s assignment of DBusMember::DBUS_MEMBER

fn validate_body(msg: &Message) -> Result<(), AtspiError>

Validate the body signature against the zvariant::Signature of MessageConversion::Body

impl<'msg> MessageConversionExt<'msg, EventBody<'msg>> for ChildrenChangedEvent

fn try_from_message( msg: &'msg Message, header: &Header<'_>, ) -> Result<ChildrenChangedEvent, AtspiError>

Convert a zbus::Message into this event type. Does all the validation for you.

fn validate_interface(header: &Header<'_>) -> Result<(), AtspiError>

Validate the interface string via zbus::message::Header::interface against Self’s assignment of DBusInterface::DBUS_INTERFACE

fn validate_member(hdr: &Header<'_>) -> Result<(), AtspiError>

Validate the member string via zbus::message::Header::member against Self’s assignment of DBusMember::DBUS_MEMBER

fn validate_body(msg: &Message) -> Result<(), AtspiError>

Validate the body signature against the zvariant::Signature of MessageConversion::Body

impl<'msg> MessageConversionExt<'msg, EventBody<'msg>> for CloseEvent

fn try_from_message( msg: &'msg Message, header: &Header<'_>, ) -> Result<CloseEvent, AtspiError>

Convert a zbus::Message into this event type. Does all the validation for you.

fn validate_interface(header: &Header<'_>) -> Result<(), AtspiError>

Validate the interface string via zbus::message::Header::interface against Self’s assignment of DBusInterface::DBUS_INTERFACE

fn validate_member(hdr: &Header<'_>) -> Result<(), AtspiError>

Validate the member string via zbus::message::Header::member against Self’s assignment of DBusMember::DBUS_MEMBER

fn validate_body(msg: &Message) -> Result<(), AtspiError>

Validate the body signature against the zvariant::Signature of MessageConversion::Body

impl<'msg> MessageConversionExt<'msg, EventBody<'msg>> for ColumnCountChangedEvent

fn try_from_message( msg: &'msg Message, header: &Header<'_>, ) -> Result<ColumnCountChangedEvent, AtspiError>

Convert a zbus::Message into this event type. Does all the validation for you.

fn validate_interface(header: &Header<'_>) -> Result<(), AtspiError>

Validate the interface string via zbus::message::Header::interface against Self’s assignment of DBusInterface::DBUS_INTERFACE

fn validate_member(hdr: &Header<'_>) -> Result<(), AtspiError>

Validate the member string via zbus::message::Header::member against Self’s assignment of DBusMember::DBUS_MEMBER

fn validate_body(msg: &Message) -> Result<(), AtspiError>

Validate the body signature against the zvariant::Signature of MessageConversion::Body

impl<'msg> MessageConversionExt<'msg, EventBody<'msg>> for ColumnDeletedEvent

fn try_from_message( msg: &'msg Message, header: &Header<'_>, ) -> Result<ColumnDeletedEvent, AtspiError>

Convert a zbus::Message into this event type. Does all the validation for you.

fn validate_interface(header: &Header<'_>) -> Result<(), AtspiError>

Validate the interface string via zbus::message::Header::interface against Self’s assignment of DBusInterface::DBUS_INTERFACE

fn validate_member(hdr: &Header<'_>) -> Result<(), AtspiError>

Validate the member string via zbus::message::Header::member against Self’s assignment of DBusMember::DBUS_MEMBER

fn validate_body(msg: &Message) -> Result<(), AtspiError>

Validate the body signature against the zvariant::Signature of MessageConversion::Body

impl<'msg> MessageConversionExt<'msg, EventBody<'msg>> for ColumnInsertedEvent

fn try_from_message( msg: &'msg Message, header: &Header<'_>, ) -> Result<ColumnInsertedEvent, AtspiError>

Convert a zbus::Message into this event type. Does all the validation for you.

fn validate_interface(header: &Header<'_>) -> Result<(), AtspiError>

Validate the interface string via zbus::message::Header::interface against Self’s assignment of DBusInterface::DBUS_INTERFACE

fn validate_member(hdr: &Header<'_>) -> Result<(), AtspiError>

Validate the member string via zbus::message::Header::member against Self’s assignment of DBusMember::DBUS_MEMBER

fn validate_body(msg: &Message) -> Result<(), AtspiError>

Validate the body signature against the zvariant::Signature of MessageConversion::Body

impl<'msg> MessageConversionExt<'msg, EventBody<'msg>> for ColumnReorderedEvent

fn try_from_message( msg: &'msg Message, header: &Header<'_>, ) -> Result<ColumnReorderedEvent, AtspiError>

Convert a zbus::Message into this event type. Does all the validation for you.

fn validate_interface(header: &Header<'_>) -> Result<(), AtspiError>

Validate the interface string via zbus::message::Header::interface against Self’s assignment of DBusInterface::DBUS_INTERFACE

fn validate_member(hdr: &Header<'_>) -> Result<(), AtspiError>

Validate the member string via zbus::message::Header::member against Self’s assignment of DBusMember::DBUS_MEMBER

fn validate_body(msg: &Message) -> Result<(), AtspiError>

Validate the body signature against the zvariant::Signature of MessageConversion::Body

impl<'msg> MessageConversionExt<'msg, EventBody<'msg>> for ContentChangedEvent

fn try_from_message( msg: &'msg Message, header: &Header<'_>, ) -> Result<ContentChangedEvent, AtspiError>

Convert a zbus::Message into this event type. Does all the validation for you.

fn validate_interface(header: &Header<'_>) -> Result<(), AtspiError>

Validate the interface string via zbus::message::Header::interface against Self’s assignment of DBusInterface::DBUS_INTERFACE

fn validate_member(hdr: &Header<'_>) -> Result<(), AtspiError>

Validate the member string via zbus::message::Header::member against Self’s assignment of DBusMember::DBUS_MEMBER

fn validate_body(msg: &Message) -> Result<(), AtspiError>

Validate the body signature against the zvariant::Signature of MessageConversion::Body

impl<'msg> MessageConversionExt<'msg, EventBody<'msg>> for CreateEvent

fn try_from_message( msg: &'msg Message, header: &Header<'_>, ) -> Result<CreateEvent, AtspiError>

Convert a zbus::Message into this event type. Does all the validation for you.

fn validate_interface(header: &Header<'_>) -> Result<(), AtspiError>

Validate the interface string via zbus::message::Header::interface against Self’s assignment of DBusInterface::DBUS_INTERFACE

fn validate_member(hdr: &Header<'_>) -> Result<(), AtspiError>

Validate the member string via zbus::message::Header::member against Self’s assignment of DBusMember::DBUS_MEMBER

fn validate_body(msg: &Message) -> Result<(), AtspiError>

Validate the body signature against the zvariant::Signature of MessageConversion::Body

impl<'msg> MessageConversionExt<'msg, EventBody<'msg>> for DeactivateEvent

fn try_from_message( msg: &'msg Message, header: &Header<'_>, ) -> Result<DeactivateEvent, AtspiError>

Convert a zbus::Message into this event type. Does all the validation for you.

fn validate_interface(header: &Header<'_>) -> Result<(), AtspiError>

Validate the interface string via zbus::message::Header::interface against Self’s assignment of DBusInterface::DBUS_INTERFACE

fn validate_member(hdr: &Header<'_>) -> Result<(), AtspiError>

Validate the member string via zbus::message::Header::member against Self’s assignment of DBusMember::DBUS_MEMBER

fn validate_body(msg: &Message) -> Result<(), AtspiError>

Validate the body signature against the zvariant::Signature of MessageConversion::Body

impl<'msg> MessageConversionExt<'msg, EventBody<'msg>> for DesktopCreateEvent

fn try_from_message( msg: &'msg Message, header: &Header<'_>, ) -> Result<DesktopCreateEvent, AtspiError>

Convert a zbus::Message into this event type. Does all the validation for you.

fn validate_interface(header: &Header<'_>) -> Result<(), AtspiError>

Validate the interface string via zbus::message::Header::interface against Self’s assignment of DBusInterface::DBUS_INTERFACE

fn validate_member(hdr: &Header<'_>) -> Result<(), AtspiError>

Validate the member string via zbus::message::Header::member against Self’s assignment of DBusMember::DBUS_MEMBER

fn validate_body(msg: &Message) -> Result<(), AtspiError>

Validate the body signature against the zvariant::Signature of MessageConversion::Body

impl<'msg> MessageConversionExt<'msg, EventBody<'msg>> for DesktopDestroyEvent

fn try_from_message( msg: &'msg Message, header: &Header<'_>, ) -> Result<DesktopDestroyEvent, AtspiError>

Convert a zbus::Message into this event type. Does all the validation for you.

fn validate_interface(header: &Header<'_>) -> Result<(), AtspiError>

Validate the interface string via zbus::message::Header::interface against Self’s assignment of DBusInterface::DBUS_INTERFACE

fn validate_member(hdr: &Header<'_>) -> Result<(), AtspiError>

Validate the member string via zbus::message::Header::member against Self’s assignment of DBusMember::DBUS_MEMBER

fn validate_body(msg: &Message) -> Result<(), AtspiError>

Validate the body signature against the zvariant::Signature of MessageConversion::Body

impl<'msg> MessageConversionExt<'msg, EventBody<'msg>> for DestroyEvent

fn try_from_message( msg: &'msg Message, header: &Header<'_>, ) -> Result<DestroyEvent, AtspiError>

Convert a zbus::Message into this event type. Does all the validation for you.

fn validate_interface(header: &Header<'_>) -> Result<(), AtspiError>

Validate the interface string via zbus::message::Header::interface against Self’s assignment of DBusInterface::DBUS_INTERFACE

fn validate_member(hdr: &Header<'_>) -> Result<(), AtspiError>

Validate the member string via zbus::message::Header::member against Self’s assignment of DBusMember::DBUS_MEMBER

fn validate_body(msg: &Message) -> Result<(), AtspiError>

Validate the body signature against the zvariant::Signature of MessageConversion::Body

impl<'msg> MessageConversionExt<'msg, EventBody<'msg>> for FocusEvent

fn try_from_message( msg: &'msg Message, header: &Header<'_>, ) -> Result<FocusEvent, AtspiError>

Convert a zbus::Message into this event type. Does all the validation for you.

fn validate_interface(header: &Header<'_>) -> Result<(), AtspiError>

Validate the interface string via zbus::message::Header::interface against Self’s assignment of DBusInterface::DBUS_INTERFACE

fn validate_member(hdr: &Header<'_>) -> Result<(), AtspiError>

Validate the member string via zbus::message::Header::member against Self’s assignment of DBusMember::DBUS_MEMBER

fn validate_body(msg: &Message) -> Result<(), AtspiError>

Validate the body signature against the zvariant::Signature of MessageConversion::Body

impl<'msg> MessageConversionExt<'msg, EventBody<'msg>> for LineChangedEvent

fn try_from_message( msg: &'msg Message, header: &Header<'_>, ) -> Result<LineChangedEvent, AtspiError>

Convert a zbus::Message into this event type. Does all the validation for you.

fn validate_interface(header: &Header<'_>) -> Result<(), AtspiError>

Validate the interface string via zbus::message::Header::interface against Self’s assignment of DBusInterface::DBUS_INTERFACE

fn validate_member(hdr: &Header<'_>) -> Result<(), AtspiError>

Validate the member string via zbus::message::Header::member against Self’s assignment of DBusMember::DBUS_MEMBER

fn validate_body(msg: &Message) -> Result<(), AtspiError>

Validate the body signature against the zvariant::Signature of MessageConversion::Body

impl<'msg> MessageConversionExt<'msg, EventBody<'msg>> for LineCountChangedEvent

fn try_from_message( msg: &'msg Message, header: &Header<'_>, ) -> Result<LineCountChangedEvent, AtspiError>

Convert a zbus::Message into this event type. Does all the validation for you.

fn validate_interface(header: &Header<'_>) -> Result<(), AtspiError>

Validate the interface string via zbus::message::Header::interface against Self’s assignment of DBusInterface::DBUS_INTERFACE

fn validate_member(hdr: &Header<'_>) -> Result<(), AtspiError>

Validate the member string via zbus::message::Header::member against Self’s assignment of DBusMember::DBUS_MEMBER

fn validate_body(msg: &Message) -> Result<(), AtspiError>

Validate the body signature against the zvariant::Signature of MessageConversion::Body

impl<'msg> MessageConversionExt<'msg, EventBody<'msg>> for LinkSelectedEvent

fn try_from_message( msg: &'msg Message, header: &Header<'_>, ) -> Result<LinkSelectedEvent, AtspiError>

Convert a zbus::Message into this event type. Does all the validation for you.

fn validate_interface(header: &Header<'_>) -> Result<(), AtspiError>

Validate the interface string via zbus::message::Header::interface against Self’s assignment of DBusInterface::DBUS_INTERFACE

fn validate_member(hdr: &Header<'_>) -> Result<(), AtspiError>

Validate the member string via zbus::message::Header::member against Self’s assignment of DBusMember::DBUS_MEMBER

fn validate_body(msg: &Message) -> Result<(), AtspiError>

Validate the body signature against the zvariant::Signature of MessageConversion::Body

impl<'msg> MessageConversionExt<'msg, EventBody<'msg>> for LoadCompleteEvent

fn try_from_message( msg: &'msg Message, header: &Header<'_>, ) -> Result<LoadCompleteEvent, AtspiError>

Convert a zbus::Message into this event type. Does all the validation for you.

fn validate_interface(header: &Header<'_>) -> Result<(), AtspiError>

Validate the interface string via zbus::message::Header::interface against Self’s assignment of DBusInterface::DBUS_INTERFACE

fn validate_member(hdr: &Header<'_>) -> Result<(), AtspiError>

Validate the member string via zbus::message::Header::member against Self’s assignment of DBusMember::DBUS_MEMBER

fn validate_body(msg: &Message) -> Result<(), AtspiError>

Validate the body signature against the zvariant::Signature of MessageConversion::Body

impl<'msg> MessageConversionExt<'msg, EventBody<'msg>> for LoadStoppedEvent

fn try_from_message( msg: &'msg Message, header: &Header<'_>, ) -> Result<LoadStoppedEvent, AtspiError>

Convert a zbus::Message into this event type. Does all the validation for you.

fn validate_interface(header: &Header<'_>) -> Result<(), AtspiError>

Validate the interface string via zbus::message::Header::interface against Self’s assignment of DBusInterface::DBUS_INTERFACE

fn validate_member(hdr: &Header<'_>) -> Result<(), AtspiError>

Validate the member string via zbus::message::Header::member against Self’s assignment of DBusMember::DBUS_MEMBER

fn validate_body(msg: &Message) -> Result<(), AtspiError>

Validate the body signature against the zvariant::Signature of MessageConversion::Body

impl<'msg> MessageConversionExt<'msg, EventBody<'msg>> for LowerEvent

fn try_from_message( msg: &'msg Message, header: &Header<'_>, ) -> Result<LowerEvent, AtspiError>

Convert a zbus::Message into this event type. Does all the validation for you.

fn validate_interface(header: &Header<'_>) -> Result<(), AtspiError>

Validate the interface string via zbus::message::Header::interface against Self’s assignment of DBusInterface::DBUS_INTERFACE

fn validate_member(hdr: &Header<'_>) -> Result<(), AtspiError>

Validate the member string via zbus::message::Header::member against Self’s assignment of DBusMember::DBUS_MEMBER

fn validate_body(msg: &Message) -> Result<(), AtspiError>

Validate the body signature against the zvariant::Signature of MessageConversion::Body

impl<'msg> MessageConversionExt<'msg, EventBody<'msg>> for MaximizeEvent

fn try_from_message( msg: &'msg Message, header: &Header<'_>, ) -> Result<MaximizeEvent, AtspiError>

Convert a zbus::Message into this event type. Does all the validation for you.

fn validate_interface(header: &Header<'_>) -> Result<(), AtspiError>

Validate the interface string via zbus::message::Header::interface against Self’s assignment of DBusInterface::DBUS_INTERFACE

fn validate_member(hdr: &Header<'_>) -> Result<(), AtspiError>

Validate the member string via zbus::message::Header::member against Self’s assignment of DBusMember::DBUS_MEMBER

fn validate_body(msg: &Message) -> Result<(), AtspiError>

Validate the body signature against the zvariant::Signature of MessageConversion::Body

impl<'msg> MessageConversionExt<'msg, EventBody<'msg>> for MinimizeEvent

fn try_from_message( msg: &'msg Message, header: &Header<'_>, ) -> Result<MinimizeEvent, AtspiError>

Convert a zbus::Message into this event type. Does all the validation for you.

fn validate_interface(header: &Header<'_>) -> Result<(), AtspiError>

Validate the interface string via zbus::message::Header::interface against Self’s assignment of DBusInterface::DBUS_INTERFACE

fn validate_member(hdr: &Header<'_>) -> Result<(), AtspiError>

Validate the member string via zbus::message::Header::member against Self’s assignment of DBusMember::DBUS_MEMBER

fn validate_body(msg: &Message) -> Result<(), AtspiError>

Validate the body signature against the zvariant::Signature of MessageConversion::Body

impl<'msg> MessageConversionExt<'msg, EventBody<'msg>> for ModelChangedEvent

fn try_from_message( msg: &'msg Message, header: &Header<'_>, ) -> Result<ModelChangedEvent, AtspiError>

Convert a zbus::Message into this event type. Does all the validation for you.

fn validate_interface(header: &Header<'_>) -> Result<(), AtspiError>

Validate the interface string via zbus::message::Header::interface against Self’s assignment of DBusInterface::DBUS_INTERFACE

fn validate_member(hdr: &Header<'_>) -> Result<(), AtspiError>

Validate the member string via zbus::message::Header::member against Self’s assignment of DBusMember::DBUS_MEMBER

fn validate_body(msg: &Message) -> Result<(), AtspiError>

Validate the body signature against the zvariant::Signature of MessageConversion::Body

impl<'msg> MessageConversionExt<'msg, EventBody<'msg>> for ModifiersEvent

fn try_from_message( msg: &'msg Message, header: &Header<'_>, ) -> Result<ModifiersEvent, AtspiError>

Convert a zbus::Message into this event type. Does all the validation for you.

fn validate_interface(header: &Header<'_>) -> Result<(), AtspiError>

Validate the interface string via zbus::message::Header::interface against Self’s assignment of DBusInterface::DBUS_INTERFACE

fn validate_member(hdr: &Header<'_>) -> Result<(), AtspiError>

Validate the member string via zbus::message::Header::member against Self’s assignment of DBusMember::DBUS_MEMBER

fn validate_body(msg: &Message) -> Result<(), AtspiError>

Validate the body signature against the zvariant::Signature of MessageConversion::Body

impl<'msg> MessageConversionExt<'msg, EventBody<'msg>> for MoveEvent

fn try_from_message( msg: &'msg Message, header: &Header<'_>, ) -> Result<MoveEvent, AtspiError>

Convert a zbus::Message into this event type. Does all the validation for you.

fn validate_interface(header: &Header<'_>) -> Result<(), AtspiError>

Validate the interface string via zbus::message::Header::interface against Self’s assignment of DBusInterface::DBUS_INTERFACE

fn validate_member(hdr: &Header<'_>) -> Result<(), AtspiError>

Validate the member string via zbus::message::Header::member against Self’s assignment of DBusMember::DBUS_MEMBER

fn validate_body(msg: &Message) -> Result<(), AtspiError>

Validate the body signature against the zvariant::Signature of MessageConversion::Body

impl<'msg> MessageConversionExt<'msg, EventBody<'msg>> for PageChangedEvent

fn try_from_message( msg: &'msg Message, header: &Header<'_>, ) -> Result<PageChangedEvent, AtspiError>

Convert a zbus::Message into this event type. Does all the validation for you.

fn validate_interface(header: &Header<'_>) -> Result<(), AtspiError>

Validate the interface string via zbus::message::Header::interface against Self’s assignment of DBusInterface::DBUS_INTERFACE

fn validate_member(hdr: &Header<'_>) -> Result<(), AtspiError>

Validate the member string via zbus::message::Header::member against Self’s assignment of DBusMember::DBUS_MEMBER

fn validate_body(msg: &Message) -> Result<(), AtspiError>

Validate the body signature against the zvariant::Signature of MessageConversion::Body

impl<'msg> MessageConversionExt<'msg, EventBody<'msg>> for PropertyChangeEvent

fn try_from_message( msg: &'msg Message, header: &Header<'_>, ) -> Result<PropertyChangeEvent, AtspiError>

Convert a zbus::Message into this event type. Does all the validation for you.

fn validate_interface(header: &Header<'_>) -> Result<(), AtspiError>

Validate the interface string via zbus::message::Header::interface against Self’s assignment of DBusInterface::DBUS_INTERFACE

fn validate_member(hdr: &Header<'_>) -> Result<(), AtspiError>

Validate the member string via zbus::message::Header::member against Self’s assignment of DBusMember::DBUS_MEMBER

fn validate_body(msg: &Message) -> Result<(), AtspiError>

Validate the body signature against the zvariant::Signature of MessageConversion::Body

impl<'msg> MessageConversionExt<'msg, EventBody<'msg>> for PropertyChangeEvent

fn try_from_message( msg: &'msg Message, header: &Header<'_>, ) -> Result<PropertyChangeEvent, AtspiError>

Convert a zbus::Message into this event type. Does all the validation for you.

fn validate_interface(header: &Header<'_>) -> Result<(), AtspiError>

Validate the interface string via zbus::message::Header::interface against Self’s assignment of DBusInterface::DBUS_INTERFACE

fn validate_member(hdr: &Header<'_>) -> Result<(), AtspiError>

Validate the member string via zbus::message::Header::member against Self’s assignment of DBusMember::DBUS_MEMBER

fn validate_body(msg: &Message) -> Result<(), AtspiError>

Validate the body signature against the zvariant::Signature of MessageConversion::Body

impl<'msg> MessageConversionExt<'msg, EventBody<'msg>> for RaiseEvent

fn try_from_message( msg: &'msg Message, header: &Header<'_>, ) -> Result<RaiseEvent, AtspiError>

Convert a zbus::Message into this event type. Does all the validation for you.

fn validate_interface(header: &Header<'_>) -> Result<(), AtspiError>

Validate the interface string via zbus::message::Header::interface against Self’s assignment of DBusInterface::DBUS_INTERFACE

fn validate_member(hdr: &Header<'_>) -> Result<(), AtspiError>

Validate the member string via zbus::message::Header::member against Self’s assignment of DBusMember::DBUS_MEMBER

fn validate_body(msg: &Message) -> Result<(), AtspiError>

Validate the body signature against the zvariant::Signature of MessageConversion::Body

impl<'msg> MessageConversionExt<'msg, EventBody<'msg>> for RelEvent

fn try_from_message( msg: &'msg Message, header: &Header<'_>, ) -> Result<RelEvent, AtspiError>

Convert a zbus::Message into this event type. Does all the validation for you.

fn validate_interface(header: &Header<'_>) -> Result<(), AtspiError>

Validate the interface string via zbus::message::Header::interface against Self’s assignment of DBusInterface::DBUS_INTERFACE

fn validate_member(hdr: &Header<'_>) -> Result<(), AtspiError>

Validate the member string via zbus::message::Header::member against Self’s assignment of DBusMember::DBUS_MEMBER

fn validate_body(msg: &Message) -> Result<(), AtspiError>

Validate the body signature against the zvariant::Signature of MessageConversion::Body

impl<'msg> MessageConversionExt<'msg, EventBody<'msg>> for ReloadEvent

fn try_from_message( msg: &'msg Message, header: &Header<'_>, ) -> Result<ReloadEvent, AtspiError>

Convert a zbus::Message into this event type. Does all the validation for you.

fn validate_interface(header: &Header<'_>) -> Result<(), AtspiError>

Validate the interface string via zbus::message::Header::interface against Self’s assignment of DBusInterface::DBUS_INTERFACE

fn validate_member(hdr: &Header<'_>) -> Result<(), AtspiError>

Validate the member string via zbus::message::Header::member against Self’s assignment of DBusMember::DBUS_MEMBER

fn validate_body(msg: &Message) -> Result<(), AtspiError>

Validate the body signature against the zvariant::Signature of MessageConversion::Body

impl<'msg> MessageConversionExt<'msg, EventBody<'msg>> for ReparentEvent

fn try_from_message( msg: &'msg Message, header: &Header<'_>, ) -> Result<ReparentEvent, AtspiError>

Convert a zbus::Message into this event type. Does all the validation for you.

fn validate_interface(header: &Header<'_>) -> Result<(), AtspiError>

Validate the interface string via zbus::message::Header::interface against Self’s assignment of DBusInterface::DBUS_INTERFACE

fn validate_member(hdr: &Header<'_>) -> Result<(), AtspiError>

Validate the member string via zbus::message::Header::member against Self’s assignment of DBusMember::DBUS_MEMBER

fn validate_body(msg: &Message) -> Result<(), AtspiError>

Validate the body signature against the zvariant::Signature of MessageConversion::Body

impl<'msg> MessageConversionExt<'msg, EventBody<'msg>> for ResizeEvent

fn try_from_message( msg: &'msg Message, header: &Header<'_>, ) -> Result<ResizeEvent, AtspiError>

Convert a zbus::Message into this event type. Does all the validation for you.

fn validate_interface(header: &Header<'_>) -> Result<(), AtspiError>

Validate the interface string via zbus::message::Header::interface against Self’s assignment of DBusInterface::DBUS_INTERFACE

fn validate_member(hdr: &Header<'_>) -> Result<(), AtspiError>

Validate the member string via zbus::message::Header::member against Self’s assignment of DBusMember::DBUS_MEMBER

fn validate_body(msg: &Message) -> Result<(), AtspiError>

Validate the body signature against the zvariant::Signature of MessageConversion::Body

impl<'msg> MessageConversionExt<'msg, EventBody<'msg>> for RestoreEvent

fn try_from_message( msg: &'msg Message, header: &Header<'_>, ) -> Result<RestoreEvent, AtspiError>

Convert a zbus::Message into this event type. Does all the validation for you.

fn validate_interface(header: &Header<'_>) -> Result<(), AtspiError>

Validate the interface string via zbus::message::Header::interface against Self’s assignment of DBusInterface::DBUS_INTERFACE

fn validate_member(hdr: &Header<'_>) -> Result<(), AtspiError>

Validate the member string via zbus::message::Header::member against Self’s assignment of DBusMember::DBUS_MEMBER

fn validate_body(msg: &Message) -> Result<(), AtspiError>

Validate the body signature against the zvariant::Signature of MessageConversion::Body

impl<'msg> MessageConversionExt<'msg, EventBody<'msg>> for RestyleEvent

fn try_from_message( msg: &'msg Message, header: &Header<'_>, ) -> Result<RestyleEvent, AtspiError>

Convert a zbus::Message into this event type. Does all the validation for you.

fn validate_interface(header: &Header<'_>) -> Result<(), AtspiError>

Validate the interface string via zbus::message::Header::interface against Self’s assignment of DBusInterface::DBUS_INTERFACE

fn validate_member(hdr: &Header<'_>) -> Result<(), AtspiError>

Validate the member string via zbus::message::Header::member against Self’s assignment of DBusMember::DBUS_MEMBER

fn validate_body(msg: &Message) -> Result<(), AtspiError>

Validate the body signature against the zvariant::Signature of MessageConversion::Body

impl<'msg> MessageConversionExt<'msg, EventBody<'msg>> for RowDeletedEvent

fn try_from_message( msg: &'msg Message, header: &Header<'_>, ) -> Result<RowDeletedEvent, AtspiError>

Convert a zbus::Message into this event type. Does all the validation for you.

fn validate_interface(header: &Header<'_>) -> Result<(), AtspiError>

Validate the interface string via zbus::message::Header::interface against Self’s assignment of DBusInterface::DBUS_INTERFACE

fn validate_member(hdr: &Header<'_>) -> Result<(), AtspiError>

Validate the member string via zbus::message::Header::member against Self’s assignment of DBusMember::DBUS_MEMBER

fn validate_body(msg: &Message) -> Result<(), AtspiError>

Validate the body signature against the zvariant::Signature of MessageConversion::Body

impl<'msg> MessageConversionExt<'msg, EventBody<'msg>> for RowInsertedEvent

fn try_from_message( msg: &'msg Message, header: &Header<'_>, ) -> Result<RowInsertedEvent, AtspiError>

Convert a zbus::Message into this event type. Does all the validation for you.

fn validate_interface(header: &Header<'_>) -> Result<(), AtspiError>

Validate the interface string via zbus::message::Header::interface against Self’s assignment of DBusInterface::DBUS_INTERFACE

fn validate_member(hdr: &Header<'_>) -> Result<(), AtspiError>

Validate the member string via zbus::message::Header::member against Self’s assignment of DBusMember::DBUS_MEMBER

fn validate_body(msg: &Message) -> Result<(), AtspiError>

Validate the body signature against the zvariant::Signature of MessageConversion::Body

impl<'msg> MessageConversionExt<'msg, EventBody<'msg>> for RowReorderedEvent

fn try_from_message( msg: &'msg Message, header: &Header<'_>, ) -> Result<RowReorderedEvent, AtspiError>

Convert a zbus::Message into this event type. Does all the validation for you.

fn validate_interface(header: &Header<'_>) -> Result<(), AtspiError>

Validate the interface string via zbus::message::Header::interface against Self’s assignment of DBusInterface::DBUS_INTERFACE

fn validate_member(hdr: &Header<'_>) -> Result<(), AtspiError>

Validate the member string via zbus::message::Header::member against Self’s assignment of DBusMember::DBUS_MEMBER

fn validate_body(msg: &Message) -> Result<(), AtspiError>

Validate the body signature against the zvariant::Signature of MessageConversion::Body

impl<'msg> MessageConversionExt<'msg, EventBody<'msg>> for SelectionChangedEvent

fn try_from_message( msg: &'msg Message, header: &Header<'_>, ) -> Result<SelectionChangedEvent, AtspiError>

Convert a zbus::Message into this event type. Does all the validation for you.

fn validate_interface(header: &Header<'_>) -> Result<(), AtspiError>

Validate the interface string via zbus::message::Header::interface against Self’s assignment of DBusInterface::DBUS_INTERFACE

fn validate_member(hdr: &Header<'_>) -> Result<(), AtspiError>

Validate the member string via zbus::message::Header::member against Self’s assignment of DBusMember::DBUS_MEMBER

fn validate_body(msg: &Message) -> Result<(), AtspiError>

Validate the body signature against the zvariant::Signature of MessageConversion::Body

impl<'msg> MessageConversionExt<'msg, EventBody<'msg>> for ShadeEvent

fn try_from_message( msg: &'msg Message, header: &Header<'_>, ) -> Result<ShadeEvent, AtspiError>

Convert a zbus::Message into this event type. Does all the validation for you.

fn validate_interface(header: &Header<'_>) -> Result<(), AtspiError>

Validate the interface string via zbus::message::Header::interface against Self’s assignment of DBusInterface::DBUS_INTERFACE

fn validate_member(hdr: &Header<'_>) -> Result<(), AtspiError>

Validate the member string via zbus::message::Header::member against Self’s assignment of DBusMember::DBUS_MEMBER

fn validate_body(msg: &Message) -> Result<(), AtspiError>

Validate the body signature against the zvariant::Signature of MessageConversion::Body

impl<'msg> MessageConversionExt<'msg, EventBody<'msg>> for StateChangedEvent

fn try_from_message( msg: &'msg Message, header: &Header<'_>, ) -> Result<StateChangedEvent, AtspiError>

Convert a zbus::Message into this event type. Does all the validation for you.

fn validate_interface(header: &Header<'_>) -> Result<(), AtspiError>

Validate the interface string via zbus::message::Header::interface against Self’s assignment of DBusInterface::DBUS_INTERFACE

fn validate_member(hdr: &Header<'_>) -> Result<(), AtspiError>

Validate the member string via zbus::message::Header::member against Self’s assignment of DBusMember::DBUS_MEMBER

fn validate_body(msg: &Message) -> Result<(), AtspiError>

Validate the body signature against the zvariant::Signature of MessageConversion::Body

impl<'msg> MessageConversionExt<'msg, EventBody<'msg>> for TextAttributesChangedEvent

fn try_from_message( msg: &'msg Message, header: &Header<'_>, ) -> Result<TextAttributesChangedEvent, AtspiError>

Convert a zbus::Message into this event type. Does all the validation for you.

fn validate_interface(header: &Header<'_>) -> Result<(), AtspiError>

Validate the interface string via zbus::message::Header::interface against Self’s assignment of DBusInterface::DBUS_INTERFACE

fn validate_member(hdr: &Header<'_>) -> Result<(), AtspiError>

Validate the member string via zbus::message::Header::member against Self’s assignment of DBusMember::DBUS_MEMBER

fn validate_body(msg: &Message) -> Result<(), AtspiError>

Validate the body signature against the zvariant::Signature of MessageConversion::Body

impl<'msg> MessageConversionExt<'msg, EventBody<'msg>> for TextBoundsChangedEvent

fn try_from_message( msg: &'msg Message, header: &Header<'_>, ) -> Result<TextBoundsChangedEvent, AtspiError>

Convert a zbus::Message into this event type. Does all the validation for you.

fn validate_interface(header: &Header<'_>) -> Result<(), AtspiError>

Validate the interface string via zbus::message::Header::interface against Self’s assignment of DBusInterface::DBUS_INTERFACE

fn validate_member(hdr: &Header<'_>) -> Result<(), AtspiError>

Validate the member string via zbus::message::Header::member against Self’s assignment of DBusMember::DBUS_MEMBER

fn validate_body(msg: &Message) -> Result<(), AtspiError>

Validate the body signature against the zvariant::Signature of MessageConversion::Body

impl<'msg> MessageConversionExt<'msg, EventBody<'msg>> for TextCaretMovedEvent

fn try_from_message( msg: &'msg Message, header: &Header<'_>, ) -> Result<TextCaretMovedEvent, AtspiError>

Convert a zbus::Message into this event type. Does all the validation for you.

fn validate_interface(header: &Header<'_>) -> Result<(), AtspiError>

Validate the interface string via zbus::message::Header::interface against Self’s assignment of DBusInterface::DBUS_INTERFACE

fn validate_member(hdr: &Header<'_>) -> Result<(), AtspiError>

Validate the member string via zbus::message::Header::member against Self’s assignment of DBusMember::DBUS_MEMBER

fn validate_body(msg: &Message) -> Result<(), AtspiError>

Validate the body signature against the zvariant::Signature of MessageConversion::Body

impl<'msg> MessageConversionExt<'msg, EventBody<'msg>> for TextChangedEvent

fn try_from_message( msg: &'msg Message, header: &Header<'_>, ) -> Result<TextChangedEvent, AtspiError>

Convert a zbus::Message into this event type. Does all the validation for you.

fn validate_interface(header: &Header<'_>) -> Result<(), AtspiError>

Validate the interface string via zbus::message::Header::interface against Self’s assignment of DBusInterface::DBUS_INTERFACE

fn validate_member(hdr: &Header<'_>) -> Result<(), AtspiError>

Validate the member string via zbus::message::Header::member against Self’s assignment of DBusMember::DBUS_MEMBER

fn validate_body(msg: &Message) -> Result<(), AtspiError>

Validate the body signature against the zvariant::Signature of MessageConversion::Body

impl<'msg> MessageConversionExt<'msg, EventBody<'msg>> for TextSelectionChangedEvent

fn try_from_message( msg: &'msg Message, header: &Header<'_>, ) -> Result<TextSelectionChangedEvent, AtspiError>

Convert a zbus::Message into this event type. Does all the validation for you.

fn validate_interface(header: &Header<'_>) -> Result<(), AtspiError>

Validate the interface string via zbus::message::Header::interface against Self’s assignment of DBusInterface::DBUS_INTERFACE

fn validate_member(hdr: &Header<'_>) -> Result<(), AtspiError>

Validate the member string via zbus::message::Header::member against Self’s assignment of DBusMember::DBUS_MEMBER

fn validate_body(msg: &Message) -> Result<(), AtspiError>

Validate the body signature against the zvariant::Signature of MessageConversion::Body

impl<'msg> MessageConversionExt<'msg, EventBody<'msg>> for UUshadeEvent

fn try_from_message( msg: &'msg Message, header: &Header<'_>, ) -> Result<UUshadeEvent, AtspiError>

Convert a zbus::Message into this event type. Does all the validation for you.

fn validate_interface(header: &Header<'_>) -> Result<(), AtspiError>

Validate the interface string via zbus::message::Header::interface against Self’s assignment of DBusInterface::DBUS_INTERFACE

fn validate_member(hdr: &Header<'_>) -> Result<(), AtspiError>

Validate the member string via zbus::message::Header::member against Self’s assignment of DBusMember::DBUS_MEMBER

fn validate_body(msg: &Message) -> Result<(), AtspiError>

Validate the body signature against the zvariant::Signature of MessageConversion::Body

impl<'msg> MessageConversionExt<'msg, EventBody<'msg>> for VisibleDataChangedEvent

fn try_from_message( msg: &'msg Message, header: &Header<'_>, ) -> Result<VisibleDataChangedEvent, AtspiError>

Convert a zbus::Message into this event type. Does all the validation for you.

fn validate_interface(header: &Header<'_>) -> Result<(), AtspiError>

Validate the interface string via zbus::message::Header::interface against Self’s assignment of DBusInterface::DBUS_INTERFACE

fn validate_member(hdr: &Header<'_>) -> Result<(), AtspiError>

Validate the member string via zbus::message::Header::member against Self’s assignment of DBusMember::DBUS_MEMBER

fn validate_body(msg: &Message) -> Result<(), AtspiError>

Validate the body signature against the zvariant::Signature of MessageConversion::Body

impl<'a> PartialEq for EventBody<'a>

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl Serialize for EventBody<'_>

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl TryFrom<EventBody<'_>> for Property

type Error = AtspiError

The type returned in the event of a conversion error.

fn try_from( body: EventBody<'_>, ) -> Result<Property, <Property as TryFrom<EventBody<'_>>>::Error>

Performs the conversion.

impl Type for EventBody<'_>

const SIGNATURE: &'static Signature = EventBodyOwned::SIGNATURE

The signature for the implementing type, in parsed format.

impl<'a> StructuralPartialEq for EventBody<'a>