Struct gio::DBusConnection

pub struct DBusConnection(_, _);

Implementations

impl DBusConnection

pub fn register_object<MethodCall, SetProperty, GetProperty>(
    &self,
    object_path: &str,
    interface_info: &DBusInterfaceInfo,
    method_call: MethodCall,
    get_property: GetProperty,
    set_property: SetProperty
) -> Result<RegistrationId, Error> where
    MethodCall: Fn(DBusConnection, &str, &str, &str, &str, Variant, DBusMethodInvocation) + Send + Sync + 'static,
    GetProperty: Fn(DBusConnection, &str, &str, &str, &str) -> Variant + Send + Sync + 'static,
    SetProperty: Fn(DBusConnection, &str, &str, &str, &str, Variant) -> bool + Send + Sync + 'static, 

pub fn unregister_object(
    &self,
    registration_id: RegistrationId
) -> Result<(), BoolError>

pub fn export_action_group<P: IsA<ActionGroup>>(
    &self,
    object_path: &str,
    action_group: &P
) -> Result<ActionGroupExportId, Error>

pub fn unexport_action_group(&self, export_id: ActionGroupExportId)

pub fn export_menu_model<P: IsA<MenuModel>>(
    &self,
    object_path: &str,
    menu: &P
) -> Result<MenuModelExportId, Error>

pub fn unexport_menu_model(&self, export_id: MenuModelExportId)

pub fn add_filter<P: Fn(&DBusConnection, &DBusMessage, bool) -> Option<DBusMessage> + 'static>(
    &self,
    filter_function: P
) -> FilterId

pub fn remove_filter(&self, filter_id: FilterId)

pub fn signal_subscribe<P: Fn(&DBusConnection, &str, &str, &str, &str, &Variant) + 'static>(
    &self,
    sender: Option<&str>,
    interface_name: Option<&str>,
    member: Option<&str>,
    object_path: Option<&str>,
    arg0: Option<&str>,
    flags: DBusSignalFlags,
    callback: P
) -> SignalSubscriptionId

pub fn signal_unsubscribe(&self, subscription_id: SignalSubscriptionId)

impl DBusConnection

pub fn new_for_address_sync<P: IsA<Cancellable>>(
    address: &str,
    flags: DBusConnectionFlags,
    observer: Option<&DBusAuthObserver>,
    cancellable: Option<&P>
) -> Result<DBusConnection, Error>

pub fn new_sync<P: IsA<IOStream>, Q: IsA<Cancellable>>(
    stream: &P,
    guid: Option<&str>,
    flags: DBusConnectionFlags,
    observer: Option<&DBusAuthObserver>,
    cancellable: Option<&Q>
) -> Result<DBusConnection, Error>

pub fn call<P: IsA<Cancellable>, Q: FnOnce(Result<Variant, Error>) + Send + 'static>(
    &self,
    bus_name: Option<&str>,
    object_path: &str,
    interface_name: &str,
    method_name: &str,
    parameters: Option<&Variant>,
    reply_type: Option<&VariantTy>,
    flags: DBusCallFlags,
    timeout_msec: i32,
    cancellable: Option<&P>,
    callback: Q
)

pub fn call_future(
    &self,
    bus_name: Option<&str>,
    object_path: &str,
    interface_name: &str,
    method_name: &str,
    parameters: Option<&Variant>,
    reply_type: Option<&VariantTy>,
    flags: DBusCallFlags,
    timeout_msec: i32
) -> Pin<Box_<dyn Future<Output = Result<Variant, Error>> + 'static>>

pub fn call_sync<P: IsA<Cancellable>>(
    &self,
    bus_name: Option<&str>,
    object_path: &str,
    interface_name: &str,
    method_name: &str,
    parameters: Option<&Variant>,
    reply_type: Option<&VariantTy>,
    flags: DBusCallFlags,
    timeout_msec: i32,
    cancellable: Option<&P>
) -> Result<Variant, Error>

pub fn call_with_unix_fd_list<P: IsA<UnixFDList>, Q: IsA<Cancellable>, R: FnOnce(Result<(Variant, UnixFDList), Error>) + Send + 'static>(
    &self,
    bus_name: Option<&str>,
    object_path: &str,
    interface_name: &str,
    method_name: &str,
    parameters: Option<&Variant>,
    reply_type: Option<&VariantTy>,
    flags: DBusCallFlags,
    timeout_msec: i32,
    fd_list: Option<&P>,
    cancellable: Option<&Q>,
    callback: R
)

pub fn call_with_unix_fd_list_future<P: IsA<UnixFDList> + Clone + 'static>(
    &self,
    bus_name: Option<&str>,
    object_path: &str,
    interface_name: &str,
    method_name: &str,
    parameters: Option<&Variant>,
    reply_type: Option<&VariantTy>,
    flags: DBusCallFlags,
    timeout_msec: i32,
    fd_list: Option<&P>
) -> Pin<Box_<dyn Future<Output = Result<(Variant, UnixFDList), Error>> + 'static>>

pub fn call_with_unix_fd_list_sync<P: IsA<UnixFDList>, Q: IsA<Cancellable>>(
    &self,
    bus_name: Option<&str>,
    object_path: &str,
    interface_name: &str,
    method_name: &str,
    parameters: Option<&Variant>,
    reply_type: Option<&VariantTy>,
    flags: DBusCallFlags,
    timeout_msec: i32,
    fd_list: Option<&P>,
    cancellable: Option<&Q>
) -> Result<(Variant, UnixFDList), Error>

pub fn close<P: IsA<Cancellable>, Q: FnOnce(Result<(), Error>) + Send + 'static>(
    &self,
    cancellable: Option<&P>,
    callback: Q
)

pub fn close_future(
    &self
) -> Pin<Box_<dyn Future<Output = Result<(), Error>> + 'static>>

pub fn close_sync<P: IsA<Cancellable>>(
    &self,
    cancellable: Option<&P>
) -> Result<(), Error>

pub fn emit_signal(
    &self,
    destination_bus_name: Option<&str>,
    object_path: &str,
    interface_name: &str,
    signal_name: &str,
    parameters: Option<&Variant>
) -> Result<(), Error>

pub fn flush<P: IsA<Cancellable>, Q: FnOnce(Result<(), Error>) + Send + 'static>(
    &self,
    cancellable: Option<&P>,
    callback: Q
)

pub fn flush_future(
    &self
) -> Pin<Box_<dyn Future<Output = Result<(), Error>> + 'static>>

pub fn flush_sync<P: IsA<Cancellable>>(
    &self,
    cancellable: Option<&P>
) -> Result<(), Error>

pub fn get_capabilities(&self) -> DBusCapabilityFlags

pub fn get_exit_on_close(&self) -> bool

pub fn get_flags(&self) -> DBusConnectionFlags

pub fn get_guid(&self) -> Option<GString>

pub fn get_last_serial(&self) -> u32

pub fn get_peer_credentials(&self) -> Option<Credentials>

pub fn get_stream(&self) -> Option<IOStream>

pub fn get_unique_name(&self) -> Option<GString>

pub fn is_closed(&self) -> bool

pub fn send_message(
    &self,
    message: &DBusMessage,
    flags: DBusSendMessageFlags
) -> Result<u32, Error>

pub fn send_message_with_reply<P: IsA<Cancellable>, Q: FnOnce(Result<DBusMessage, Error>) + Send + 'static>(
    &self,
    message: &DBusMessage,
    flags: DBusSendMessageFlags,
    timeout_msec: i32,
    cancellable: Option<&P>,
    callback: Q
) -> u32

pub fn send_message_with_reply_future(
    &self,
    message: &DBusMessage,
    flags: DBusSendMessageFlags,
    timeout_msec: i32
) -> Pin<Box_<dyn Future<Output = Result<DBusMessage, Error>> + 'static>>

pub fn send_message_with_reply_sync<P: IsA<Cancellable>>(
    &self,
    message: &DBusMessage,
    flags: DBusSendMessageFlags,
    timeout_msec: i32,
    cancellable: Option<&P>
) -> Result<(DBusMessage, u32), Error>

pub fn set_exit_on_close(&self, exit_on_close: bool)

pub fn start_message_processing(&self)

pub fn get_property_closed(&self) -> bool

pub fn get_property_flags(&self) -> DBusConnectionFlags

pub fn new<P: IsA<IOStream>, Q: IsA<Cancellable>, R: FnOnce(Result<DBusConnection, Error>) + Send + 'static>(
    stream: &P,
    guid: Option<&str>,
    flags: DBusConnectionFlags,
    observer: Option<&DBusAuthObserver>,
    cancellable: Option<&Q>,
    callback: R
)

pub fn new_future<P: IsA<IOStream> + Clone + 'static>(
    stream: &P,
    guid: Option<&str>,
    flags: DBusConnectionFlags,
    observer: Option<&DBusAuthObserver>
) -> Pin<Box_<dyn Future<Output = Result<DBusConnection, Error>> + 'static>>

pub fn new_for_address<P: IsA<Cancellable>, Q: FnOnce(Result<DBusConnection, Error>) + Send + 'static>(
    address: &str,
    flags: DBusConnectionFlags,
    observer: Option<&DBusAuthObserver>,
    cancellable: Option<&P>,
    callback: Q
)

pub fn new_for_address_future(
    address: &str,
    flags: DBusConnectionFlags,
    observer: Option<&DBusAuthObserver>
) -> Pin<Box_<dyn Future<Output = Result<DBusConnection, Error>> + 'static>>

pub fn connect_closed<F: Fn(&DBusConnection, bool, Option<&Error>) + 'static>(
    &self,
    f: F
) -> SignalHandlerId

pub fn connect_property_capabilities_notify<F: Fn(&DBusConnection) + 'static>(
    &self,
    f: F
) -> SignalHandlerId

pub fn connect_property_closed_notify<F: Fn(&DBusConnection) + 'static>(
    &self,
    f: F
) -> SignalHandlerId

pub fn connect_property_exit_on_close_notify<F: Fn(&DBusConnection) + 'static>(
    &self,
    f: F
) -> SignalHandlerId

pub fn connect_property_unique_name_notify<F: Fn(&DBusConnection) + 'static>(
    &self,
    f: F
) -> SignalHandlerId

Trait Implementations

impl Clone for DBusConnection

fn clone(&self) -> DBusConnection

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for DBusConnection

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

Formats the value using the given formatter.

impl Display for DBusConnection

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

Formats the value using the given formatter.

impl Eq for DBusConnection

impl Hash for DBusConnection

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, 

Feeds a slice of this type into the given [Hasher].

impl Ord for DBusConnection

fn cmp(&self, other: &DBusConnection) -> Ordering

This method returns an [Ordering] between self and other.

#[must_use]fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

#[must_use]fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

#[must_use]fn clamp(self, min: Self, max: Self) -> Self

🔬 This is a nightly-only experimental API. (clamp)

Restrict a value to a certain interval.

impl<T: ObjectType> PartialEq<T> for DBusConnection

fn eq(&self, other: &T) -> bool

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

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<T: ObjectType> PartialOrd<T> for DBusConnection

fn partial_cmp(&self, other: &T) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

#[must_use]fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

#[must_use]fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

#[must_use]fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

#[must_use]fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl StaticType for DBusConnection

fn static_type() -> Type

Returns the type identifier of Self.