Struct EventBodyBorrowed

pub struct EventBodyBorrowed<'a> {
    pub kind: &'a str,
    pub detail1: i32,
    pub detail2: i32,
    pub any_data: Value<'a>,
    /* private fields */
}

Fields

kind: &'a str

kind variant, used for specifying an event triple “object:state-changed:focused”, the “focus” part of this event is what is contained within the kind.

detail1: i32

Generic detail1 value described by AT-SPI.

detail2: i32

Generic detail2 value described by AT-SPI.

any_data: Value<'a>

Generic any_data value described by AT-SPI. This can be any type.

Implementations

impl EventBodyBorrowed<'_>

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

Convert this borrowed event body to an owned event body.

Errors

This 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.

Chances are slim because none of the types in crate::events use [std::os::fd::OwnedFd].
See zvariant::Value::try_clone for more information.

Trait Implementations

impl Clone for EventBodyBorrowed<'_>

fn clone(&self) -> Self

Safety

This implementation of Clone can panic! although chances are slim.

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.

Then this function panic.
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.
See zvariant::Value::try_clone for more information.

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

Performs copy-assignment from source.

impl<'a> Debug for EventBodyBorrowed<'a>

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

Formats the value using the given formatter.

impl Default for EventBodyBorrowed<'_>

fn default() -> Self

Returns the “default value” for a type.

impl<'de: 'a, 'a> Deserialize<'de> for EventBodyBorrowed<'a>

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'a> From<EventBodyBorrowed<'a>> for EventBodyQtOwned

fn from(borrowed: EventBodyBorrowed<'a>) -> Self

Converts to this type from the input type.

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

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

Converts to this type from the input type.

impl<'de> From<EventBodyQtBorrowed<'de>> for EventBodyBorrowed<'de>

fn from(borrow: EventBodyQtBorrowed<'de>) -> Self

Converts to this type from the input type.

impl PartialEq<EventBodyBorrowed<'_>> for EventBodyQtBorrowed<'_>

fn eq(&self, other: &EventBodyBorrowed<'_>) -> 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 PartialEq<EventBodyQtBorrowed<'_>> for EventBodyBorrowed<'_>

fn eq(&self, other: &EventBodyQtBorrowed<'_>) -> 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<'a> PartialEq for EventBodyBorrowed<'a>

fn eq(&self, other: &EventBodyBorrowed<'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<'a> Serialize for EventBodyBorrowed<'a>

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<'a> Type for EventBodyBorrowed<'a>

const SIGNATURE: &'static Signature

The signature for the implementing type, in parsed format.

impl<'a> StructuralPartialEq for EventBodyBorrowed<'a>