Trait Interface

pub trait Interface:
    Any
    + Send
    + Sync {
    // Required methods
    fn name() -> InterfaceName<'static>
       where Self: Sized;
    fn get<'life0, 'life1, 'life2, 'life3, 'life4, 'life5, 'life6, 'life7, 'async_trait>(
        &'life0 self,
        property_name: &'life1 str,
        server: &'life2 ObjectServer,
        connection: &'life3 Connection,
        header: Option<&'life4 Header<'life5>>,
        emitter: &'life6 SignalEmitter<'life7>,
    ) -> Pin<Box<dyn Future<Output = Option<Result<OwnedValue>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait,
             'life3: 'async_trait,
             'life4: 'async_trait,
             'life5: 'async_trait,
             'life6: 'async_trait,
             'life7: 'async_trait;
    fn get_all<'life0, 'life1, 'life2, 'life3, 'life4, 'life5, 'life6, 'async_trait>(
        &'life0 self,
        object_server: &'life1 ObjectServer,
        connection: &'life2 Connection,
        header: Option<&'life3 Header<'life4>>,
        emitter: &'life5 SignalEmitter<'life6>,
    ) -> Pin<Box<dyn Future<Output = Result<HashMap<String, OwnedValue>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait,
             'life3: 'async_trait,
             'life4: 'async_trait,
             'life5: 'async_trait,
             'life6: 'async_trait;
    fn set_mut<'life0, 'life1, 'life2, 'life3, 'life4, 'life5, 'life6, 'life7, 'life8, 'life9, 'async_trait>(
        &'life0 mut self,
        property_name: &'life1 str,
        value: &'life2 Value<'life3>,
        object_server: &'life4 ObjectServer,
        connection: &'life5 Connection,
        header: Option<&'life6 Header<'life7>>,
        emitter: &'life8 SignalEmitter<'life9>,
    ) -> Pin<Box<dyn Future<Output = Option<Result<()>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait,
             'life3: 'async_trait,
             'life4: 'async_trait,
             'life5: 'async_trait,
             'life6: 'async_trait,
             'life7: 'async_trait,
             'life8: 'async_trait,
             'life9: 'async_trait;
    fn call<'call>(
        &'call self,
        server: &'call ObjectServer,
        connection: &'call Connection,
        msg: &'call Message,
        name: MemberName<'call>,
    ) -> DispatchResult<'call>;
    fn call_mut<'call>(
        &'call mut self,
        server: &'call ObjectServer,
        connection: &'call Connection,
        msg: &'call Message,
        name: MemberName<'call>,
    ) -> DispatchResult<'call>;
    fn introspect_to_writer(&self, writer: &mut dyn Write, level: usize);

    // Provided methods
    fn spawn_tasks_for_methods(&self) -> bool { ... }
    fn set<'call>(
        &'call self,
        property_name: &'call str,
        value: &'call Value<'_>,
        object_server: &'call ObjectServer,
        connection: &'call Connection,
        header: Option<&'call Header<'_>>,
        emitter: &'call SignalEmitter<'_>,
    ) -> DispatchResult<'call> { ... }
}

This trait is used to dispatch messages to an interface instance.

This trait should be treated as an unstable API and compatibility may break in minor version bumps. Because of this and other reasons, it is not recommended to manually implement this trait. The crate::interface macro implements it for you.

If you have an advanced use case where interface is inadequate, consider using crate::MessageStream or crate::blocking::MessageIterator instead.

Required Methods

fn name() -> InterfaceName<'static>

where Self: Sized,

Return the name of the interface. Ex: “org.foo.MyInterface”

fn get<'life0, 'life1, 'life2, 'life3, 'life4, 'life5, 'life6, 'life7, 'async_trait>( &'life0 self, property_name: &'life1 str, server: &'life2 ObjectServer, connection: &'life3 Connection, header: Option<&'life4 Header<'life5>>, emitter: &'life6 SignalEmitter<'life7>, ) -> Pin<Box<dyn Future<Output = Option<Result<OwnedValue>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait, 'life5: 'async_trait, 'life6: 'async_trait, 'life7: 'async_trait,

Get a property value. Returns None if the property doesn’t exist.

Note: The header parameter will be None when the getter is not being called as part of D-Bus communication (for example, when it is called as part of initial object setup, before it is registered on the bus, or when we manually send out property changed notifications).

fn get_all<'life0, 'life1, 'life2, 'life3, 'life4, 'life5, 'life6, 'async_trait>( &'life0 self, object_server: &'life1 ObjectServer, connection: &'life2 Connection, header: Option<&'life3 Header<'life4>>, emitter: &'life5 SignalEmitter<'life6>, ) -> Pin<Box<dyn Future<Output = Result<HashMap<String, OwnedValue>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait, 'life5: 'async_trait, 'life6: 'async_trait,

Return all the properties.

fn set_mut<'life0, 'life1, 'life2, 'life3, 'life4, 'life5, 'life6, 'life7, 'life8, 'life9, 'async_trait>( &'life0 mut self, property_name: &'life1 str, value: &'life2 Value<'life3>, object_server: &'life4 ObjectServer, connection: &'life5 Connection, header: Option<&'life6 Header<'life7>>, emitter: &'life8 SignalEmitter<'life9>, ) -> Pin<Box<dyn Future<Output = Option<Result<()>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait, 'life5: 'async_trait, 'life6: 'async_trait, 'life7: 'async_trait, 'life8: 'async_trait, 'life9: 'async_trait,

Set a property value.

Returns None if the property doesn’t exist.

This will only be invoked if set returned RequiresMut.

fn call<'call>( &'call self, server: &'call ObjectServer, connection: &'call Connection, msg: &'call Message, name: MemberName<'call>, ) -> DispatchResult<'call>

Call a method.

Return DispatchResult::NotFound if the method doesn’t exist, or DispatchResult::RequiresMut if call_mut should be used instead.

It is valid, though inefficient, for this to always return RequiresMut.

fn call_mut<'call>( &'call mut self, server: &'call ObjectServer, connection: &'call Connection, msg: &'call Message, name: MemberName<'call>, ) -> DispatchResult<'call>

Call a &mut self method.

This will only be invoked if call returned RequiresMut.

fn introspect_to_writer(&self, writer: &mut dyn Write, level: usize)

Write introspection XML to the writer, with the given indentation level.

Provided Methods

fn spawn_tasks_for_methods(&self) -> bool

Whether each method call will be handled from a different spawned task.

Note: When methods are called from separate tasks, they may not be run in the order in which they were called.

fn set<'call>( &'call self, property_name: &'call str, value: &'call Value<'_>, object_server: &'call ObjectServer, connection: &'call Connection, header: Option<&'call Header<'_>>, emitter: &'call SignalEmitter<'_>, ) -> DispatchResult<'call>

Set a property value.

Return DispatchResult::NotFound if the property doesn’t exist, or DispatchResult::RequiresMut if set_mut should be used instead. The default implementation just returns RequiresMut.

Implementors

impl Interface for ObjectManager

impl Interface for Properties