Struct UnitProxy

pub struct UnitProxy<'p>(/* private fields */);

Implementations

impl<'p> UnitProxy<'p>

pub async fn new(conn: &Connection) -> Result<UnitProxy<'p>>

Creates a new proxy with the default service and path.

pub fn builder(conn: &Connection) -> Builder<'p, Self>

Returns a customizable builder for this proxy.

pub fn into_inner(self) -> Proxy<'p>

Consumes self, returning the underlying zbus::Proxy.

pub fn inner(&self) -> &Proxy<'p>

The reference to the underlying zbus::Proxy.

pub fn inner_mut(&mut self) -> &mut Proxy<'p>

The mutable reference to the underlying zbus::Proxy.

pub async fn clean(&self, mask: &[&str]) -> Result<()>

Clean method

pub async fn enqueue_job( &self, job_type: &str, job_mode: &str, ) -> Result<(Job, Vec<Job>)>

EnqueueJob method

pub async fn kill(&self, whom: &str, signal: i32) -> Result<()>

Kill method

pub async fn reload(&self, mode: &str) -> Result<OwnedObjectPath>

Reload method

pub async fn reload_or_restart(&self, mode: &str) -> Result<OwnedObjectPath>

ReloadOrRestart method

pub async fn reload_or_try_restart(&self, mode: &str) -> Result<OwnedObjectPath>

ReloadOrTryRestart method

pub async fn reset_failed(&self) -> Result<()>

ResetFailed method

pub async fn restart(&self, mode: &str) -> Result<OwnedObjectPath>

Restart method

pub async fn set_properties( &self, runtime: bool, properties: &[(&str, Value<'_>)], ) -> Result<()>

SetProperties method

pub async fn start(&self, mode: &str) -> Result<OwnedObjectPath>

Start method

pub async fn stop(&self, mode: &str) -> Result<OwnedObjectPath>

Stop method

pub async fn try_restart(&self, mode: &str) -> Result<OwnedObjectPath>

TryRestart method

pub async fn access_selinux_context(&self) -> Result<String>

AccessSELinuxContext property

pub fn cached_access_selinux_context( &self, ) -> Result<Option<<Result<String> as ResultAdapter>::Ok>, <Result<String> as ResultAdapter>::Err>

Get the cached value of the AccessSELinuxContext property, or None if the property is not cached.

pub async fn receive_access_selinux_context_changed( &self, ) -> PropertyStream<'p, <Result<String> as ResultAdapter>::Ok>

Create a stream for the AccessSELinuxContext property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn activation_details(&self) -> Result<Vec<KeyValue<String, String>>>

ActivationDetails property

pub fn cached_activation_details( &self, ) -> Result<Option<<Result<Vec<KeyValue<String, String>>> as ResultAdapter>::Ok>, <Result<Vec<KeyValue<String, String>>> as ResultAdapter>::Err>

Get the cached value of the ActivationDetails property, or None if the property is not cached.

pub async fn receive_activation_details_changed( &self, ) -> PropertyStream<'p, <Result<Vec<KeyValue<String, String>>> as ResultAdapter>::Ok>

Create a stream for the ActivationDetails property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn active_enter_timestamp(&self) -> Result<u64>

ActiveEnterTimestamp property

pub fn cached_active_enter_timestamp( &self, ) -> Result<Option<<Result<u64> as ResultAdapter>::Ok>, <Result<u64> as ResultAdapter>::Err>

Get the cached value of the ActiveEnterTimestamp property, or None if the property is not cached.

pub async fn receive_active_enter_timestamp_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

Create a stream for the ActiveEnterTimestamp property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn active_enter_timestamp_monotonic(&self) -> Result<u64>

ActiveEnterTimestampMonotonic property

pub fn cached_active_enter_timestamp_monotonic( &self, ) -> Result<Option<<Result<u64> as ResultAdapter>::Ok>, <Result<u64> as ResultAdapter>::Err>

Get the cached value of the ActiveEnterTimestampMonotonic property, or None if the property is not cached.

pub async fn receive_active_enter_timestamp_monotonic_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

Create a stream for the ActiveEnterTimestampMonotonic property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn active_exit_timestamp(&self) -> Result<u64>

ActiveExitTimestamp property

pub fn cached_active_exit_timestamp( &self, ) -> Result<Option<<Result<u64> as ResultAdapter>::Ok>, <Result<u64> as ResultAdapter>::Err>

Get the cached value of the ActiveExitTimestamp property, or None if the property is not cached.

pub async fn receive_active_exit_timestamp_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

Create a stream for the ActiveExitTimestamp property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn active_exit_timestamp_monotonic(&self) -> Result<u64>

ActiveExitTimestampMonotonic property

pub fn cached_active_exit_timestamp_monotonic( &self, ) -> Result<Option<<Result<u64> as ResultAdapter>::Ok>, <Result<u64> as ResultAdapter>::Err>

Get the cached value of the ActiveExitTimestampMonotonic property, or None if the property is not cached.

pub async fn receive_active_exit_timestamp_monotonic_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

Create a stream for the ActiveExitTimestampMonotonic property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn active_state(&self) -> Result<ActiveState>

ActiveState property

pub fn cached_active_state( &self, ) -> Result<Option<<Result<ActiveState> as ResultAdapter>::Ok>, <Result<ActiveState> as ResultAdapter>::Err>

Get the cached value of the ActiveState property, or None if the property is not cached.

pub async fn receive_active_state_changed( &self, ) -> PropertyStream<'p, <Result<ActiveState> as ResultAdapter>::Ok>

Create a stream for the ActiveState property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn after(&self) -> Result<Vec<String>>

After property

pub fn cached_after( &self, ) -> Result<Option<<Result<Vec<String>> as ResultAdapter>::Ok>, <Result<Vec<String>> as ResultAdapter>::Err>

Get the cached value of the After property, or None if the property is not cached.

pub async fn receive_after_changed( &self, ) -> PropertyStream<'p, <Result<Vec<String>> as ResultAdapter>::Ok>

Create a stream for the After property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn allow_isolate(&self) -> Result<bool>

AllowIsolate property

pub fn cached_allow_isolate( &self, ) -> Result<Option<<Result<bool> as ResultAdapter>::Ok>, <Result<bool> as ResultAdapter>::Err>

Get the cached value of the AllowIsolate property, or None if the property is not cached.

pub async fn receive_allow_isolate_changed( &self, ) -> PropertyStream<'p, <Result<bool> as ResultAdapter>::Ok>

Create a stream for the AllowIsolate property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn assert_result(&self) -> Result<bool>

AssertResult property

pub fn cached_assert_result( &self, ) -> Result<Option<<Result<bool> as ResultAdapter>::Ok>, <Result<bool> as ResultAdapter>::Err>

Get the cached value of the AssertResult property, or None if the property is not cached.

pub async fn receive_assert_result_changed( &self, ) -> PropertyStream<'p, <Result<bool> as ResultAdapter>::Ok>

Create a stream for the AssertResult property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn assert_timestamp(&self) -> Result<u64>

AssertTimestamp property

pub fn cached_assert_timestamp( &self, ) -> Result<Option<<Result<u64> as ResultAdapter>::Ok>, <Result<u64> as ResultAdapter>::Err>

Get the cached value of the AssertTimestamp property, or None if the property is not cached.

pub async fn receive_assert_timestamp_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

Create a stream for the AssertTimestamp property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn assert_timestamp_monotonic(&self) -> Result<u64>

AssertTimestampMonotonic property

pub fn cached_assert_timestamp_monotonic( &self, ) -> Result<Option<<Result<u64> as ResultAdapter>::Ok>, <Result<u64> as ResultAdapter>::Err>

Get the cached value of the AssertTimestampMonotonic property, or None if the property is not cached.

pub async fn receive_assert_timestamp_monotonic_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

Create a stream for the AssertTimestampMonotonic property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn before(&self) -> Result<Vec<String>>

Before property

pub fn cached_before( &self, ) -> Result<Option<<Result<Vec<String>> as ResultAdapter>::Ok>, <Result<Vec<String>> as ResultAdapter>::Err>

Get the cached value of the Before property, or None if the property is not cached.

pub async fn receive_before_changed( &self, ) -> PropertyStream<'p, <Result<Vec<String>> as ResultAdapter>::Ok>

Create a stream for the Before property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn binds_to(&self) -> Result<Vec<String>>

BindsTo property

pub fn cached_binds_to( &self, ) -> Result<Option<<Result<Vec<String>> as ResultAdapter>::Ok>, <Result<Vec<String>> as ResultAdapter>::Err>

Get the cached value of the BindsTo property, or None if the property is not cached.

pub async fn receive_binds_to_changed( &self, ) -> PropertyStream<'p, <Result<Vec<String>> as ResultAdapter>::Ok>

Create a stream for the BindsTo property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn bound_by(&self) -> Result<Vec<String>>

BoundBy property

pub fn cached_bound_by( &self, ) -> Result<Option<<Result<Vec<String>> as ResultAdapter>::Ok>, <Result<Vec<String>> as ResultAdapter>::Err>

Get the cached value of the BoundBy property, or None if the property is not cached.

pub async fn receive_bound_by_changed( &self, ) -> PropertyStream<'p, <Result<Vec<String>> as ResultAdapter>::Ok>

Create a stream for the BoundBy property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn can_clean(&self) -> Result<Vec<String>>

CanClean property

pub fn cached_can_clean( &self, ) -> Result<Option<<Result<Vec<String>> as ResultAdapter>::Ok>, <Result<Vec<String>> as ResultAdapter>::Err>

Get the cached value of the CanClean property, or None if the property is not cached.

pub async fn receive_can_clean_changed( &self, ) -> PropertyStream<'p, <Result<Vec<String>> as ResultAdapter>::Ok>

Create a stream for the CanClean property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn can_freeze(&self) -> Result<bool>

CanFreeze property

pub fn cached_can_freeze( &self, ) -> Result<Option<<Result<bool> as ResultAdapter>::Ok>, <Result<bool> as ResultAdapter>::Err>

Get the cached value of the CanFreeze property, or None if the property is not cached.

pub async fn receive_can_freeze_changed( &self, ) -> PropertyStream<'p, <Result<bool> as ResultAdapter>::Ok>

Create a stream for the CanFreeze property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn can_isolate(&self) -> Result<bool>

CanIsolate property

pub fn cached_can_isolate( &self, ) -> Result<Option<<Result<bool> as ResultAdapter>::Ok>, <Result<bool> as ResultAdapter>::Err>

Get the cached value of the CanIsolate property, or None if the property is not cached.

pub async fn receive_can_isolate_changed( &self, ) -> PropertyStream<'p, <Result<bool> as ResultAdapter>::Ok>

Create a stream for the CanIsolate property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn can_reload(&self) -> Result<bool>

CanReload property

pub fn cached_can_reload( &self, ) -> Result<Option<<Result<bool> as ResultAdapter>::Ok>, <Result<bool> as ResultAdapter>::Err>

Get the cached value of the CanReload property, or None if the property is not cached.

pub async fn receive_can_reload_changed( &self, ) -> PropertyStream<'p, <Result<bool> as ResultAdapter>::Ok>

Create a stream for the CanReload property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn can_start(&self) -> Result<bool>

CanStart property

pub fn cached_can_start( &self, ) -> Result<Option<<Result<bool> as ResultAdapter>::Ok>, <Result<bool> as ResultAdapter>::Err>

Get the cached value of the CanStart property, or None if the property is not cached.

pub async fn receive_can_start_changed( &self, ) -> PropertyStream<'p, <Result<bool> as ResultAdapter>::Ok>

Create a stream for the CanStart property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn can_stop(&self) -> Result<bool>

CanStop property

pub fn cached_can_stop( &self, ) -> Result<Option<<Result<bool> as ResultAdapter>::Ok>, <Result<bool> as ResultAdapter>::Err>

Get the cached value of the CanStop property, or None if the property is not cached.

pub async fn receive_can_stop_changed( &self, ) -> PropertyStream<'p, <Result<bool> as ResultAdapter>::Ok>

Create a stream for the CanStop property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn collect_mode(&self) -> Result<String>

CollectMode property

pub fn cached_collect_mode( &self, ) -> Result<Option<<Result<String> as ResultAdapter>::Ok>, <Result<String> as ResultAdapter>::Err>

Get the cached value of the CollectMode property, or None if the property is not cached.

pub async fn receive_collect_mode_changed( &self, ) -> PropertyStream<'p, <Result<String> as ResultAdapter>::Ok>

Create a stream for the CollectMode property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn condition_result(&self) -> Result<bool>

ConditionResult property

pub fn cached_condition_result( &self, ) -> Result<Option<<Result<bool> as ResultAdapter>::Ok>, <Result<bool> as ResultAdapter>::Err>

Get the cached value of the ConditionResult property, or None if the property is not cached.

pub async fn receive_condition_result_changed( &self, ) -> PropertyStream<'p, <Result<bool> as ResultAdapter>::Ok>

Create a stream for the ConditionResult property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn condition_timestamp(&self) -> Result<u64>

ConditionTimestamp property

pub fn cached_condition_timestamp( &self, ) -> Result<Option<<Result<u64> as ResultAdapter>::Ok>, <Result<u64> as ResultAdapter>::Err>

Get the cached value of the ConditionTimestamp property, or None if the property is not cached.

pub async fn receive_condition_timestamp_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

Create a stream for the ConditionTimestamp property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn condition_timestamp_monotonic(&self) -> Result<u64>

ConditionTimestampMonotonic property

pub fn cached_condition_timestamp_monotonic( &self, ) -> Result<Option<<Result<u64> as ResultAdapter>::Ok>, <Result<u64> as ResultAdapter>::Err>

Get the cached value of the ConditionTimestampMonotonic property, or None if the property is not cached.

pub async fn receive_condition_timestamp_monotonic_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

Create a stream for the ConditionTimestampMonotonic property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn conflicted_by(&self) -> Result<Vec<String>>

ConflictedBy property

pub fn cached_conflicted_by( &self, ) -> Result<Option<<Result<Vec<String>> as ResultAdapter>::Ok>, <Result<Vec<String>> as ResultAdapter>::Err>

Get the cached value of the ConflictedBy property, or None if the property is not cached.

pub async fn receive_conflicted_by_changed( &self, ) -> PropertyStream<'p, <Result<Vec<String>> as ResultAdapter>::Ok>

Create a stream for the ConflictedBy property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn conflicts(&self) -> Result<Vec<String>>

Conflicts property

pub fn cached_conflicts( &self, ) -> Result<Option<<Result<Vec<String>> as ResultAdapter>::Ok>, <Result<Vec<String>> as ResultAdapter>::Err>

Get the cached value of the Conflicts property, or None if the property is not cached.

pub async fn receive_conflicts_changed( &self, ) -> PropertyStream<'p, <Result<Vec<String>> as ResultAdapter>::Ok>

Create a stream for the Conflicts property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn consists_of(&self) -> Result<Vec<String>>

ConsistsOf property

pub fn cached_consists_of( &self, ) -> Result<Option<<Result<Vec<String>> as ResultAdapter>::Ok>, <Result<Vec<String>> as ResultAdapter>::Err>

Get the cached value of the ConsistsOf property, or None if the property is not cached.

pub async fn receive_consists_of_changed( &self, ) -> PropertyStream<'p, <Result<Vec<String>> as ResultAdapter>::Ok>

Create a stream for the ConsistsOf property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn default_dependencies(&self) -> Result<bool>

DefaultDependencies property

pub fn cached_default_dependencies( &self, ) -> Result<Option<<Result<bool> as ResultAdapter>::Ok>, <Result<bool> as ResultAdapter>::Err>

Get the cached value of the DefaultDependencies property, or None if the property is not cached.

pub async fn receive_default_dependencies_changed( &self, ) -> PropertyStream<'p, <Result<bool> as ResultAdapter>::Ok>

Create a stream for the DefaultDependencies property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn description(&self) -> Result<String>

Description property

pub fn cached_description( &self, ) -> Result<Option<<Result<String> as ResultAdapter>::Ok>, <Result<String> as ResultAdapter>::Err>

Get the cached value of the Description property, or None if the property is not cached.

pub async fn receive_description_changed( &self, ) -> PropertyStream<'p, <Result<String> as ResultAdapter>::Ok>

Create a stream for the Description property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn documentation(&self) -> Result<Vec<String>>

Documentation property

pub fn cached_documentation( &self, ) -> Result<Option<<Result<Vec<String>> as ResultAdapter>::Ok>, <Result<Vec<String>> as ResultAdapter>::Err>

Get the cached value of the Documentation property, or None if the property is not cached.

pub async fn receive_documentation_changed( &self, ) -> PropertyStream<'p, <Result<Vec<String>> as ResultAdapter>::Ok>

Create a stream for the Documentation property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn drop_in_paths(&self) -> Result<Vec<String>>

DropInPaths property

pub fn cached_drop_in_paths( &self, ) -> Result<Option<<Result<Vec<String>> as ResultAdapter>::Ok>, <Result<Vec<String>> as ResultAdapter>::Err>

Get the cached value of the DropInPaths property, or None if the property is not cached.

pub async fn receive_drop_in_paths_changed( &self, ) -> PropertyStream<'p, <Result<Vec<String>> as ResultAdapter>::Ok>

Create a stream for the DropInPaths property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn failure_action(&self) -> Result<String>

FailureAction property

pub fn cached_failure_action( &self, ) -> Result<Option<<Result<String> as ResultAdapter>::Ok>, <Result<String> as ResultAdapter>::Err>

Get the cached value of the FailureAction property, or None if the property is not cached.

pub async fn receive_failure_action_changed( &self, ) -> PropertyStream<'p, <Result<String> as ResultAdapter>::Ok>

Create a stream for the FailureAction property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn failure_action_exit_status(&self) -> Result<i32>

FailureActionExitStatus property

pub fn cached_failure_action_exit_status( &self, ) -> Result<Option<<Result<i32> as ResultAdapter>::Ok>, <Result<i32> as ResultAdapter>::Err>

Get the cached value of the FailureActionExitStatus property, or None if the property is not cached.

pub async fn receive_failure_action_exit_status_changed( &self, ) -> PropertyStream<'p, <Result<i32> as ResultAdapter>::Ok>

Create a stream for the FailureActionExitStatus property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn following(&self) -> Result<String>

Following property

pub fn cached_following( &self, ) -> Result<Option<<Result<String> as ResultAdapter>::Ok>, <Result<String> as ResultAdapter>::Err>

Get the cached value of the Following property, or None if the property is not cached.

pub async fn receive_following_changed( &self, ) -> PropertyStream<'p, <Result<String> as ResultAdapter>::Ok>

Create a stream for the Following property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn fragment_path(&self) -> Result<String>

FragmentPath property

pub fn cached_fragment_path( &self, ) -> Result<Option<<Result<String> as ResultAdapter>::Ok>, <Result<String> as ResultAdapter>::Err>

Get the cached value of the FragmentPath property, or None if the property is not cached.

pub async fn receive_fragment_path_changed( &self, ) -> PropertyStream<'p, <Result<String> as ResultAdapter>::Ok>

Create a stream for the FragmentPath property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn freezer_state(&self) -> Result<String>

FreezerState property

pub fn cached_freezer_state( &self, ) -> Result<Option<<Result<String> as ResultAdapter>::Ok>, <Result<String> as ResultAdapter>::Err>

Get the cached value of the FreezerState property, or None if the property is not cached.

pub async fn receive_freezer_state_changed( &self, ) -> PropertyStream<'p, <Result<String> as ResultAdapter>::Ok>

Create a stream for the FreezerState property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn id(&self) -> Result<String>

Id property

pub fn cached_id( &self, ) -> Result<Option<<Result<String> as ResultAdapter>::Ok>, <Result<String> as ResultAdapter>::Err>

Get the cached value of the Id property, or None if the property is not cached.

pub async fn receive_id_changed( &self, ) -> PropertyStream<'p, <Result<String> as ResultAdapter>::Ok>

Create a stream for the Id property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn ignore_on_isolate(&self) -> Result<bool>

IgnoreOnIsolate property

pub fn cached_ignore_on_isolate( &self, ) -> Result<Option<<Result<bool> as ResultAdapter>::Ok>, <Result<bool> as ResultAdapter>::Err>

Get the cached value of the IgnoreOnIsolate property, or None if the property is not cached.

pub async fn receive_ignore_on_isolate_changed( &self, ) -> PropertyStream<'p, <Result<bool> as ResultAdapter>::Ok>

Create a stream for the IgnoreOnIsolate property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn inactive_enter_timestamp(&self) -> Result<u64>

InactiveEnterTimestamp property

pub fn cached_inactive_enter_timestamp( &self, ) -> Result<Option<<Result<u64> as ResultAdapter>::Ok>, <Result<u64> as ResultAdapter>::Err>

Get the cached value of the InactiveEnterTimestamp property, or None if the property is not cached.

pub async fn receive_inactive_enter_timestamp_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

Create a stream for the InactiveEnterTimestamp property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn inactive_enter_timestamp_monotonic(&self) -> Result<u64>

InactiveEnterTimestampMonotonic property

pub fn cached_inactive_enter_timestamp_monotonic( &self, ) -> Result<Option<<Result<u64> as ResultAdapter>::Ok>, <Result<u64> as ResultAdapter>::Err>

Get the cached value of the InactiveEnterTimestampMonotonic property, or None if the property is not cached.

pub async fn receive_inactive_enter_timestamp_monotonic_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

Create a stream for the InactiveEnterTimestampMonotonic property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn inactive_exit_timestamp(&self) -> Result<u64>

InactiveExitTimestamp property

pub fn cached_inactive_exit_timestamp( &self, ) -> Result<Option<<Result<u64> as ResultAdapter>::Ok>, <Result<u64> as ResultAdapter>::Err>

Get the cached value of the InactiveExitTimestamp property, or None if the property is not cached.

pub async fn receive_inactive_exit_timestamp_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

Create a stream for the InactiveExitTimestamp property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn inactive_exit_timestamp_monotonic(&self) -> Result<u64>

InactiveExitTimestampMonotonic property

pub fn cached_inactive_exit_timestamp_monotonic( &self, ) -> Result<Option<<Result<u64> as ResultAdapter>::Ok>, <Result<u64> as ResultAdapter>::Err>

Get the cached value of the InactiveExitTimestampMonotonic property, or None if the property is not cached.

pub async fn receive_inactive_exit_timestamp_monotonic_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

Create a stream for the InactiveExitTimestampMonotonic property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn invocation_id(&self) -> Result<Vec<u8>>

InvocationID property

pub fn cached_invocation_id( &self, ) -> Result<Option<<Result<Vec<u8>> as ResultAdapter>::Ok>, <Result<Vec<u8>> as ResultAdapter>::Err>

Get the cached value of the InvocationID property, or None if the property is not cached.

pub async fn receive_invocation_id_changed( &self, ) -> PropertyStream<'p, <Result<Vec<u8>> as ResultAdapter>::Ok>

Create a stream for the InvocationID property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn job(&self) -> Result<(u32, OwnedObjectPath)>

Job property

pub fn cached_job( &self, ) -> Result<Option<<Result<(u32, OwnedObjectPath)> as ResultAdapter>::Ok>, <Result<(u32, OwnedObjectPath)> as ResultAdapter>::Err>

Get the cached value of the Job property, or None if the property is not cached.

pub async fn receive_job_changed( &self, ) -> PropertyStream<'p, <Result<(u32, OwnedObjectPath)> as ResultAdapter>::Ok>

Create a stream for the Job property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn job_running_timeout_usec(&self) -> Result<u64>

JobRunningTimeoutUSec property

pub fn cached_job_running_timeout_usec( &self, ) -> Result<Option<<Result<u64> as ResultAdapter>::Ok>, <Result<u64> as ResultAdapter>::Err>

Get the cached value of the JobRunningTimeoutUSec property, or None if the property is not cached.

pub async fn receive_job_running_timeout_usec_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

Create a stream for the JobRunningTimeoutUSec property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn job_timeout_action(&self) -> Result<String>

JobTimeoutAction property

pub fn cached_job_timeout_action( &self, ) -> Result<Option<<Result<String> as ResultAdapter>::Ok>, <Result<String> as ResultAdapter>::Err>

Get the cached value of the JobTimeoutAction property, or None if the property is not cached.

pub async fn receive_job_timeout_action_changed( &self, ) -> PropertyStream<'p, <Result<String> as ResultAdapter>::Ok>

Create a stream for the JobTimeoutAction property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn job_timeout_reboot_argument(&self) -> Result<String>

JobTimeoutRebootArgument property

pub fn cached_job_timeout_reboot_argument( &self, ) -> Result<Option<<Result<String> as ResultAdapter>::Ok>, <Result<String> as ResultAdapter>::Err>

Get the cached value of the JobTimeoutRebootArgument property, or None if the property is not cached.

pub async fn receive_job_timeout_reboot_argument_changed( &self, ) -> PropertyStream<'p, <Result<String> as ResultAdapter>::Ok>

Create a stream for the JobTimeoutRebootArgument property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn job_timeout_usec(&self) -> Result<u64>

JobTimeoutUSec property

pub fn cached_job_timeout_usec( &self, ) -> Result<Option<<Result<u64> as ResultAdapter>::Ok>, <Result<u64> as ResultAdapter>::Err>

Get the cached value of the JobTimeoutUSec property, or None if the property is not cached.

pub async fn receive_job_timeout_usec_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

Create a stream for the JobTimeoutUSec property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn joins_namespace_of(&self) -> Result<Vec<String>>

JoinsNamespaceOf property

pub fn cached_joins_namespace_of( &self, ) -> Result<Option<<Result<Vec<String>> as ResultAdapter>::Ok>, <Result<Vec<String>> as ResultAdapter>::Err>

Get the cached value of the JoinsNamespaceOf property, or None if the property is not cached.

pub async fn receive_joins_namespace_of_changed( &self, ) -> PropertyStream<'p, <Result<Vec<String>> as ResultAdapter>::Ok>

Create a stream for the JoinsNamespaceOf property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn load_error(&self) -> Result<(String, String)>

LoadError property

pub fn cached_load_error( &self, ) -> Result<Option<<Result<(String, String)> as ResultAdapter>::Ok>, <Result<(String, String)> as ResultAdapter>::Err>

Get the cached value of the LoadError property, or None if the property is not cached.

pub async fn receive_load_error_changed( &self, ) -> PropertyStream<'p, <Result<(String, String)> as ResultAdapter>::Ok>

Create a stream for the LoadError property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn load_state(&self) -> Result<String>

LoadState property

pub fn cached_load_state( &self, ) -> Result<Option<<Result<String> as ResultAdapter>::Ok>, <Result<String> as ResultAdapter>::Err>

Get the cached value of the LoadState property, or None if the property is not cached.

pub async fn receive_load_state_changed( &self, ) -> PropertyStream<'p, <Result<String> as ResultAdapter>::Ok>

Create a stream for the LoadState property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn markers(&self) -> Result<Vec<String>>

Markers property

pub fn cached_markers( &self, ) -> Result<Option<<Result<Vec<String>> as ResultAdapter>::Ok>, <Result<Vec<String>> as ResultAdapter>::Err>

Get the cached value of the Markers property, or None if the property is not cached.

pub async fn receive_markers_changed( &self, ) -> PropertyStream<'p, <Result<Vec<String>> as ResultAdapter>::Ok>

Create a stream for the Markers property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn names(&self) -> Result<Vec<String>>

Names property

pub fn cached_names( &self, ) -> Result<Option<<Result<Vec<String>> as ResultAdapter>::Ok>, <Result<Vec<String>> as ResultAdapter>::Err>

Get the cached value of the Names property, or None if the property is not cached.

pub async fn receive_names_changed( &self, ) -> PropertyStream<'p, <Result<Vec<String>> as ResultAdapter>::Ok>

Create a stream for the Names property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn need_daemon_reload(&self) -> Result<bool>

NeedDaemonReload property

pub fn cached_need_daemon_reload( &self, ) -> Result<Option<<Result<bool> as ResultAdapter>::Ok>, <Result<bool> as ResultAdapter>::Err>

Get the cached value of the NeedDaemonReload property, or None if the property is not cached.

pub async fn receive_need_daemon_reload_changed( &self, ) -> PropertyStream<'p, <Result<bool> as ResultAdapter>::Ok>

Create a stream for the NeedDaemonReload property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn on_failure(&self) -> Result<Vec<String>>

OnFailure property

pub fn cached_on_failure( &self, ) -> Result<Option<<Result<Vec<String>> as ResultAdapter>::Ok>, <Result<Vec<String>> as ResultAdapter>::Err>

Get the cached value of the OnFailure property, or None if the property is not cached.

pub async fn receive_on_failure_changed( &self, ) -> PropertyStream<'p, <Result<Vec<String>> as ResultAdapter>::Ok>

Create a stream for the OnFailure property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn on_failure_job_mode(&self) -> Result<String>

OnFailureJobMode property

pub fn cached_on_failure_job_mode( &self, ) -> Result<Option<<Result<String> as ResultAdapter>::Ok>, <Result<String> as ResultAdapter>::Err>

Get the cached value of the OnFailureJobMode property, or None if the property is not cached.

pub async fn receive_on_failure_job_mode_changed( &self, ) -> PropertyStream<'p, <Result<String> as ResultAdapter>::Ok>

Create a stream for the OnFailureJobMode property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn on_failure_of(&self) -> Result<Vec<String>>

OnFailureOf property

pub fn cached_on_failure_of( &self, ) -> Result<Option<<Result<Vec<String>> as ResultAdapter>::Ok>, <Result<Vec<String>> as ResultAdapter>::Err>

Get the cached value of the OnFailureOf property, or None if the property is not cached.

pub async fn receive_on_failure_of_changed( &self, ) -> PropertyStream<'p, <Result<Vec<String>> as ResultAdapter>::Ok>

Create a stream for the OnFailureOf property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn on_success(&self) -> Result<Vec<String>>

OnSuccess property

pub fn cached_on_success( &self, ) -> Result<Option<<Result<Vec<String>> as ResultAdapter>::Ok>, <Result<Vec<String>> as ResultAdapter>::Err>

Get the cached value of the OnSuccess property, or None if the property is not cached.

pub async fn receive_on_success_changed( &self, ) -> PropertyStream<'p, <Result<Vec<String>> as ResultAdapter>::Ok>

Create a stream for the OnSuccess property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn on_success_job_mode(&self) -> Result<String>

OnSuccessJobMode property

pub fn cached_on_success_job_mode( &self, ) -> Result<Option<<Result<String> as ResultAdapter>::Ok>, <Result<String> as ResultAdapter>::Err>

Get the cached value of the OnSuccessJobMode property, or None if the property is not cached.

pub async fn receive_on_success_job_mode_changed( &self, ) -> PropertyStream<'p, <Result<String> as ResultAdapter>::Ok>

Create a stream for the OnSuccessJobMode property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn on_success_of(&self) -> Result<Vec<String>>

OnSuccessOf property

pub fn cached_on_success_of( &self, ) -> Result<Option<<Result<Vec<String>> as ResultAdapter>::Ok>, <Result<Vec<String>> as ResultAdapter>::Err>

Get the cached value of the OnSuccessOf property, or None if the property is not cached.

pub async fn receive_on_success_of_changed( &self, ) -> PropertyStream<'p, <Result<Vec<String>> as ResultAdapter>::Ok>

Create a stream for the OnSuccessOf property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn part_of(&self) -> Result<Vec<String>>

PartOf property

pub fn cached_part_of( &self, ) -> Result<Option<<Result<Vec<String>> as ResultAdapter>::Ok>, <Result<Vec<String>> as ResultAdapter>::Err>

Get the cached value of the PartOf property, or None if the property is not cached.

pub async fn receive_part_of_changed( &self, ) -> PropertyStream<'p, <Result<Vec<String>> as ResultAdapter>::Ok>

Create a stream for the PartOf property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn perpetual(&self) -> Result<bool>

Perpetual property

pub fn cached_perpetual( &self, ) -> Result<Option<<Result<bool> as ResultAdapter>::Ok>, <Result<bool> as ResultAdapter>::Err>

Get the cached value of the Perpetual property, or None if the property is not cached.

pub async fn receive_perpetual_changed( &self, ) -> PropertyStream<'p, <Result<bool> as ResultAdapter>::Ok>

Create a stream for the Perpetual property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn propagates_reload_to(&self) -> Result<Vec<String>>

PropagatesReloadTo property

pub fn cached_propagates_reload_to( &self, ) -> Result<Option<<Result<Vec<String>> as ResultAdapter>::Ok>, <Result<Vec<String>> as ResultAdapter>::Err>

Get the cached value of the PropagatesReloadTo property, or None if the property is not cached.

pub async fn receive_propagates_reload_to_changed( &self, ) -> PropertyStream<'p, <Result<Vec<String>> as ResultAdapter>::Ok>

Create a stream for the PropagatesReloadTo property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn propagates_stop_to(&self) -> Result<Vec<String>>

PropagatesStopTo property

pub fn cached_propagates_stop_to( &self, ) -> Result<Option<<Result<Vec<String>> as ResultAdapter>::Ok>, <Result<Vec<String>> as ResultAdapter>::Err>

Get the cached value of the PropagatesStopTo property, or None if the property is not cached.

pub async fn receive_propagates_stop_to_changed( &self, ) -> PropertyStream<'p, <Result<Vec<String>> as ResultAdapter>::Ok>

Create a stream for the PropagatesStopTo property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn reboot_argument(&self) -> Result<String>

RebootArgument property

pub fn cached_reboot_argument( &self, ) -> Result<Option<<Result<String> as ResultAdapter>::Ok>, <Result<String> as ResultAdapter>::Err>

Get the cached value of the RebootArgument property, or None if the property is not cached.

pub async fn receive_reboot_argument_changed( &self, ) -> PropertyStream<'p, <Result<String> as ResultAdapter>::Ok>

Create a stream for the RebootArgument property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn refs(&self) -> Result<Vec<String>>

Refs property

pub fn cached_refs( &self, ) -> Result<Option<<Result<Vec<String>> as ResultAdapter>::Ok>, <Result<Vec<String>> as ResultAdapter>::Err>

Get the cached value of the Refs property, or None if the property is not cached.

pub async fn receive_refs_changed( &self, ) -> PropertyStream<'p, <Result<Vec<String>> as ResultAdapter>::Ok>

Create a stream for the Refs property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn refuse_manual_start(&self) -> Result<bool>

RefuseManualStart property

pub fn cached_refuse_manual_start( &self, ) -> Result<Option<<Result<bool> as ResultAdapter>::Ok>, <Result<bool> as ResultAdapter>::Err>

Get the cached value of the RefuseManualStart property, or None if the property is not cached.

pub async fn receive_refuse_manual_start_changed( &self, ) -> PropertyStream<'p, <Result<bool> as ResultAdapter>::Ok>

Create a stream for the RefuseManualStart property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn refuse_manual_stop(&self) -> Result<bool>

RefuseManualStop property

pub fn cached_refuse_manual_stop( &self, ) -> Result<Option<<Result<bool> as ResultAdapter>::Ok>, <Result<bool> as ResultAdapter>::Err>

Get the cached value of the RefuseManualStop property, or None if the property is not cached.

pub async fn receive_refuse_manual_stop_changed( &self, ) -> PropertyStream<'p, <Result<bool> as ResultAdapter>::Ok>

Create a stream for the RefuseManualStop property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn reload_propagated_from(&self) -> Result<Vec<String>>

ReloadPropagatedFrom property

pub fn cached_reload_propagated_from( &self, ) -> Result<Option<<Result<Vec<String>> as ResultAdapter>::Ok>, <Result<Vec<String>> as ResultAdapter>::Err>

Get the cached value of the ReloadPropagatedFrom property, or None if the property is not cached.

pub async fn receive_reload_propagated_from_changed( &self, ) -> PropertyStream<'p, <Result<Vec<String>> as ResultAdapter>::Ok>

Create a stream for the ReloadPropagatedFrom property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn required_by(&self) -> Result<Vec<String>>

RequiredBy property

pub fn cached_required_by( &self, ) -> Result<Option<<Result<Vec<String>> as ResultAdapter>::Ok>, <Result<Vec<String>> as ResultAdapter>::Err>

Get the cached value of the RequiredBy property, or None if the property is not cached.

pub async fn receive_required_by_changed( &self, ) -> PropertyStream<'p, <Result<Vec<String>> as ResultAdapter>::Ok>

Create a stream for the RequiredBy property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn requires(&self) -> Result<Vec<String>>

Requires property

pub fn cached_requires( &self, ) -> Result<Option<<Result<Vec<String>> as ResultAdapter>::Ok>, <Result<Vec<String>> as ResultAdapter>::Err>

Get the cached value of the Requires property, or None if the property is not cached.

pub async fn receive_requires_changed( &self, ) -> PropertyStream<'p, <Result<Vec<String>> as ResultAdapter>::Ok>

Create a stream for the Requires property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn requires_mounts_for(&self) -> Result<Vec<String>>

RequiresMountsFor property

pub fn cached_requires_mounts_for( &self, ) -> Result<Option<<Result<Vec<String>> as ResultAdapter>::Ok>, <Result<Vec<String>> as ResultAdapter>::Err>

Get the cached value of the RequiresMountsFor property, or None if the property is not cached.

pub async fn receive_requires_mounts_for_changed( &self, ) -> PropertyStream<'p, <Result<Vec<String>> as ResultAdapter>::Ok>

Create a stream for the RequiresMountsFor property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn requisite(&self) -> Result<Vec<String>>

Requisite property

pub fn cached_requisite( &self, ) -> Result<Option<<Result<Vec<String>> as ResultAdapter>::Ok>, <Result<Vec<String>> as ResultAdapter>::Err>

Get the cached value of the Requisite property, or None if the property is not cached.

pub async fn receive_requisite_changed( &self, ) -> PropertyStream<'p, <Result<Vec<String>> as ResultAdapter>::Ok>

Create a stream for the Requisite property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn requisite_of(&self) -> Result<Vec<String>>

RequisiteOf property

pub fn cached_requisite_of( &self, ) -> Result<Option<<Result<Vec<String>> as ResultAdapter>::Ok>, <Result<Vec<String>> as ResultAdapter>::Err>

Get the cached value of the RequisiteOf property, or None if the property is not cached.

pub async fn receive_requisite_of_changed( &self, ) -> PropertyStream<'p, <Result<Vec<String>> as ResultAdapter>::Ok>

Create a stream for the RequisiteOf property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn slice_of(&self) -> Result<Vec<String>>

SliceOf property

pub fn cached_slice_of( &self, ) -> Result<Option<<Result<Vec<String>> as ResultAdapter>::Ok>, <Result<Vec<String>> as ResultAdapter>::Err>

Get the cached value of the SliceOf property, or None if the property is not cached.

pub async fn receive_slice_of_changed( &self, ) -> PropertyStream<'p, <Result<Vec<String>> as ResultAdapter>::Ok>

Create a stream for the SliceOf property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn source_path(&self) -> Result<String>

SourcePath property

pub fn cached_source_path( &self, ) -> Result<Option<<Result<String> as ResultAdapter>::Ok>, <Result<String> as ResultAdapter>::Err>

Get the cached value of the SourcePath property, or None if the property is not cached.

pub async fn receive_source_path_changed( &self, ) -> PropertyStream<'p, <Result<String> as ResultAdapter>::Ok>

Create a stream for the SourcePath property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn start_limit_action(&self) -> Result<String>

StartLimitAction property

pub fn cached_start_limit_action( &self, ) -> Result<Option<<Result<String> as ResultAdapter>::Ok>, <Result<String> as ResultAdapter>::Err>

Get the cached value of the StartLimitAction property, or None if the property is not cached.

pub async fn receive_start_limit_action_changed( &self, ) -> PropertyStream<'p, <Result<String> as ResultAdapter>::Ok>

Create a stream for the StartLimitAction property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn start_limit_burst(&self) -> Result<u32>

StartLimitBurst property

pub fn cached_start_limit_burst( &self, ) -> Result<Option<<Result<u32> as ResultAdapter>::Ok>, <Result<u32> as ResultAdapter>::Err>

Get the cached value of the StartLimitBurst property, or None if the property is not cached.

pub async fn receive_start_limit_burst_changed( &self, ) -> PropertyStream<'p, <Result<u32> as ResultAdapter>::Ok>

Create a stream for the StartLimitBurst property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn start_limit_interval_usec(&self) -> Result<u64>

StartLimitIntervalUSec property

pub fn cached_start_limit_interval_usec( &self, ) -> Result<Option<<Result<u64> as ResultAdapter>::Ok>, <Result<u64> as ResultAdapter>::Err>

Get the cached value of the StartLimitIntervalUSec property, or None if the property is not cached.

pub async fn receive_start_limit_interval_usec_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

Create a stream for the StartLimitIntervalUSec property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn state_change_timestamp(&self) -> Result<u64>

StateChangeTimestamp property

pub fn cached_state_change_timestamp( &self, ) -> Result<Option<<Result<u64> as ResultAdapter>::Ok>, <Result<u64> as ResultAdapter>::Err>

Get the cached value of the StateChangeTimestamp property, or None if the property is not cached.

pub async fn receive_state_change_timestamp_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

Create a stream for the StateChangeTimestamp property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn state_change_timestamp_monotonic(&self) -> Result<u64>

StateChangeTimestampMonotonic property

pub fn cached_state_change_timestamp_monotonic( &self, ) -> Result<Option<<Result<u64> as ResultAdapter>::Ok>, <Result<u64> as ResultAdapter>::Err>

Get the cached value of the StateChangeTimestampMonotonic property, or None if the property is not cached.

pub async fn receive_state_change_timestamp_monotonic_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

Create a stream for the StateChangeTimestampMonotonic property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn stop_propagated_from(&self) -> Result<Vec<String>>

StopPropagatedFrom property

pub fn cached_stop_propagated_from( &self, ) -> Result<Option<<Result<Vec<String>> as ResultAdapter>::Ok>, <Result<Vec<String>> as ResultAdapter>::Err>

Get the cached value of the StopPropagatedFrom property, or None if the property is not cached.

pub async fn receive_stop_propagated_from_changed( &self, ) -> PropertyStream<'p, <Result<Vec<String>> as ResultAdapter>::Ok>

Create a stream for the StopPropagatedFrom property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn stop_when_unneeded(&self) -> Result<bool>

StopWhenUnneeded property

pub fn cached_stop_when_unneeded( &self, ) -> Result<Option<<Result<bool> as ResultAdapter>::Ok>, <Result<bool> as ResultAdapter>::Err>

Get the cached value of the StopWhenUnneeded property, or None if the property is not cached.

pub async fn receive_stop_when_unneeded_changed( &self, ) -> PropertyStream<'p, <Result<bool> as ResultAdapter>::Ok>

Create a stream for the StopWhenUnneeded property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn sub_state(&self) -> Result<String>

SubState property

pub fn cached_sub_state( &self, ) -> Result<Option<<Result<String> as ResultAdapter>::Ok>, <Result<String> as ResultAdapter>::Err>

Get the cached value of the SubState property, or None if the property is not cached.

pub async fn receive_sub_state_changed( &self, ) -> PropertyStream<'p, <Result<String> as ResultAdapter>::Ok>

Create a stream for the SubState property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn success_action(&self) -> Result<String>

SuccessAction property

pub fn cached_success_action( &self, ) -> Result<Option<<Result<String> as ResultAdapter>::Ok>, <Result<String> as ResultAdapter>::Err>

Get the cached value of the SuccessAction property, or None if the property is not cached.

pub async fn receive_success_action_changed( &self, ) -> PropertyStream<'p, <Result<String> as ResultAdapter>::Ok>

Create a stream for the SuccessAction property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn success_action_exit_status(&self) -> Result<i32>

SuccessActionExitStatus property

pub fn cached_success_action_exit_status( &self, ) -> Result<Option<<Result<i32> as ResultAdapter>::Ok>, <Result<i32> as ResultAdapter>::Err>

Get the cached value of the SuccessActionExitStatus property, or None if the property is not cached.

pub async fn receive_success_action_exit_status_changed( &self, ) -> PropertyStream<'p, <Result<i32> as ResultAdapter>::Ok>

Create a stream for the SuccessActionExitStatus property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn transient(&self) -> Result<bool>

Transient property

pub fn cached_transient( &self, ) -> Result<Option<<Result<bool> as ResultAdapter>::Ok>, <Result<bool> as ResultAdapter>::Err>

Get the cached value of the Transient property, or None if the property is not cached.

pub async fn receive_transient_changed( &self, ) -> PropertyStream<'p, <Result<bool> as ResultAdapter>::Ok>

Create a stream for the Transient property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn triggered_by(&self) -> Result<Vec<String>>

TriggeredBy property

pub fn cached_triggered_by( &self, ) -> Result<Option<<Result<Vec<String>> as ResultAdapter>::Ok>, <Result<Vec<String>> as ResultAdapter>::Err>

Get the cached value of the TriggeredBy property, or None if the property is not cached.

pub async fn receive_triggered_by_changed( &self, ) -> PropertyStream<'p, <Result<Vec<String>> as ResultAdapter>::Ok>

Create a stream for the TriggeredBy property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn triggers(&self) -> Result<Vec<String>>

Triggers property

pub fn cached_triggers( &self, ) -> Result<Option<<Result<Vec<String>> as ResultAdapter>::Ok>, <Result<Vec<String>> as ResultAdapter>::Err>

Get the cached value of the Triggers property, or None if the property is not cached.

pub async fn receive_triggers_changed( &self, ) -> PropertyStream<'p, <Result<Vec<String>> as ResultAdapter>::Ok>

Create a stream for the Triggers property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn unit_file_preset(&self) -> Result<String>

UnitFilePreset property

pub fn cached_unit_file_preset( &self, ) -> Result<Option<<Result<String> as ResultAdapter>::Ok>, <Result<String> as ResultAdapter>::Err>

Get the cached value of the UnitFilePreset property, or None if the property is not cached.

pub async fn receive_unit_file_preset_changed( &self, ) -> PropertyStream<'p, <Result<String> as ResultAdapter>::Ok>

Create a stream for the UnitFilePreset property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn unit_file_state(&self) -> Result<String>

UnitFileState property

pub fn cached_unit_file_state( &self, ) -> Result<Option<<Result<String> as ResultAdapter>::Ok>, <Result<String> as ResultAdapter>::Err>

Get the cached value of the UnitFileState property, or None if the property is not cached.

pub async fn receive_unit_file_state_changed( &self, ) -> PropertyStream<'p, <Result<String> as ResultAdapter>::Ok>

Create a stream for the UnitFileState property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn upheld_by(&self) -> Result<Vec<String>>

UpheldBy property

pub fn cached_upheld_by( &self, ) -> Result<Option<<Result<Vec<String>> as ResultAdapter>::Ok>, <Result<Vec<String>> as ResultAdapter>::Err>

Get the cached value of the UpheldBy property, or None if the property is not cached.

pub async fn receive_upheld_by_changed( &self, ) -> PropertyStream<'p, <Result<Vec<String>> as ResultAdapter>::Ok>

Create a stream for the UpheldBy property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn upholds(&self) -> Result<Vec<String>>

Upholds property

pub fn cached_upholds( &self, ) -> Result<Option<<Result<Vec<String>> as ResultAdapter>::Ok>, <Result<Vec<String>> as ResultAdapter>::Err>

Get the cached value of the Upholds property, or None if the property is not cached.

pub async fn receive_upholds_changed( &self, ) -> PropertyStream<'p, <Result<Vec<String>> as ResultAdapter>::Ok>

Create a stream for the Upholds property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn wanted_by(&self) -> Result<Vec<String>>

WantedBy property

pub fn cached_wanted_by( &self, ) -> Result<Option<<Result<Vec<String>> as ResultAdapter>::Ok>, <Result<Vec<String>> as ResultAdapter>::Err>

Get the cached value of the WantedBy property, or None if the property is not cached.

pub async fn receive_wanted_by_changed( &self, ) -> PropertyStream<'p, <Result<Vec<String>> as ResultAdapter>::Ok>

Create a stream for the WantedBy property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn wants(&self) -> Result<Vec<String>>

Wants property

pub fn cached_wants( &self, ) -> Result<Option<<Result<Vec<String>> as ResultAdapter>::Ok>, <Result<Vec<String>> as ResultAdapter>::Err>

Get the cached value of the Wants property, or None if the property is not cached.

pub async fn receive_wants_changed( &self, ) -> PropertyStream<'p, <Result<Vec<String>> as ResultAdapter>::Ok>

Create a stream for the Wants property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

Trait Implementations

impl<'p> AsMut<Proxy<'p>> for UnitProxy<'p>

fn as_mut(&mut self) -> &mut Proxy<'p>

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

impl<'p> AsRef<Proxy<'p>> for UnitProxy<'p>

fn as_ref(&self) -> &Proxy<'p>

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

impl<'p> Clone for UnitProxy<'p>

fn clone(&self) -> UnitProxy<'p>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'p> Debug for UnitProxy<'p>

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

Formats the value using the given formatter.

impl<'a> Defaults for UnitProxy<'a>

const INTERFACE: &'static Option<InterfaceName<'static>>

const DESTINATION: &'static Option<BusName<'static>>

const PATH: &'static Option<ObjectPath<'static>>

impl<'p> From<Proxy<'p>> for UnitProxy<'p>

fn from(proxy: Proxy<'p>) -> Self

Converts to this type from the input type.

impl<'p> ProxyImpl<'p> for UnitProxy<'p>

fn builder(conn: &Connection) -> Builder<'p, Self>

Return a customizable builder for this proxy.

fn into_inner(self) -> Proxy<'p>

Consume self, returning the underlying zbus::Proxy.

fn inner(&self) -> &Proxy<'p>

The reference to the underlying zbus::Proxy.

impl<'p> Serialize for UnitProxy<'p>

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

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<'p> Type for UnitProxy<'p>

const SIGNATURE: &'static Signature

The signature for the implementing type, in parsed format.