Struct ServiceProxyBlocking

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

Implementations

impl<'p> ServiceProxyBlocking<'p>

pub fn new<P>(conn: &Connection, path: P) -> Result<ServiceProxyBlocking<'p>>

where P: TryInto<ObjectPath<'p>>, P::Error: Into<Error>,

Creates a new proxy with the given path, and the default destination.

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 fn attach_processes(&self, subcgroup: &str, pids: &[u32]) -> Result<()>

AttachProcesses method

pub fn bind_mount( &self, source: &str, destination: &str, read_only: bool, mkdir: bool, ) -> Result<()>

BindMount method

pub fn get_processes(&self) -> Result<Vec<Process>>

GetProcesses method

pub fn mount_image( &self, source: &str, destination: &str, read_only: bool, mkdir: bool, options: &[(&str, &str)], ) -> Result<()>

MountImage method

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

AllowedCPUs property

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

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

pub fn receive_allowed_cpus_changed( &self, ) -> PropertyIterator<'p, <Result<Vec<u8>> as ResultAdapter>::Ok>

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

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

AllowedMemoryNodes property

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

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

pub fn receive_allowed_memory_nodes_changed( &self, ) -> PropertyIterator<'p, <Result<Vec<u8>> as ResultAdapter>::Ok>

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

pub fn ambient_capabilities(&self) -> Result<u64>

AmbientCapabilities property

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

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

pub fn receive_ambient_capabilities_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn app_armor_profile(&self) -> Result<(bool, String)>

AppArmorProfile property

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

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

pub fn receive_app_armor_profile_changed( &self, ) -> PropertyIterator<'p, <Result<(bool, String)> as ResultAdapter>::Ok>

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

pub fn bpf_program(&self) -> Result<Vec<(String, String)>>

BPFProgram property

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

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

pub fn receive_bpf_program_changed( &self, ) -> PropertyIterator<'p, <Result<Vec<(String, String)>> as ResultAdapter>::Ok>

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

pub fn bind_paths(&self) -> Result<Vec<BindMount>>

BindPaths property

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

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

pub fn receive_bind_paths_changed( &self, ) -> PropertyIterator<'p, <Result<Vec<BindMount>> as ResultAdapter>::Ok>

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

pub fn bind_read_only_paths(&self) -> Result<Vec<BindMount>>

BindReadOnlyPaths property

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

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

pub fn receive_bind_read_only_paths_changed( &self, ) -> PropertyIterator<'p, <Result<Vec<BindMount>> as ResultAdapter>::Ok>

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

pub fn block_io_accounting(&self) -> Result<bool>

BlockIOAccounting property

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

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

pub fn receive_block_io_accounting_changed( &self, ) -> PropertyIterator<'p, <Result<bool> as ResultAdapter>::Ok>

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

pub fn block_io_device_weight(&self) -> Result<Vec<(String, u64)>>

BlockIODeviceWeight property

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

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

pub fn receive_block_io_device_weight_changed( &self, ) -> PropertyIterator<'p, <Result<Vec<(String, u64)>> as ResultAdapter>::Ok>

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

pub fn block_io_read_bandwidth(&self) -> Result<Vec<(String, u64)>>

BlockIOReadBandwidth property

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

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

pub fn receive_block_io_read_bandwidth_changed( &self, ) -> PropertyIterator<'p, <Result<Vec<(String, u64)>> as ResultAdapter>::Ok>

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

pub fn block_io_weight(&self) -> Result<u64>

BlockIOWeight property

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

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

pub fn receive_block_io_weight_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn block_io_write_bandwidth(&self) -> Result<Vec<(String, u64)>>

BlockIOWriteBandwidth property

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

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

pub fn receive_block_io_write_bandwidth_changed( &self, ) -> PropertyIterator<'p, <Result<Vec<(String, u64)>> as ResultAdapter>::Ok>

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

pub fn bus_name(&self) -> Result<String>

BusName property

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

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

pub fn receive_bus_name_changed( &self, ) -> PropertyIterator<'p, <Result<String> as ResultAdapter>::Ok>

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

pub fn cpu_accounting(&self) -> Result<bool>

CPUAccounting property

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

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

pub fn receive_cpu_accounting_changed( &self, ) -> PropertyIterator<'p, <Result<bool> as ResultAdapter>::Ok>

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

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

CPUAffinity property

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

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

pub fn receive_cpu_affinity_changed( &self, ) -> PropertyIterator<'p, <Result<Vec<u8>> as ResultAdapter>::Ok>

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

pub fn cpu_affinity_from_numa(&self) -> Result<bool>

CPUAffinityFromNUMA property

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

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

pub fn receive_cpu_affinity_from_numa_changed( &self, ) -> PropertyIterator<'p, <Result<bool> as ResultAdapter>::Ok>

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

pub fn cpu_quota_per_sec_usec(&self) -> Result<u64>

CPUQuotaPerSecUSec property

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

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

pub fn receive_cpu_quota_per_sec_usec_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn cpu_quota_period_usec(&self) -> Result<u64>

CPUQuotaPeriodUSec property

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

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

pub fn receive_cpu_quota_period_usec_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn cpu_scheduling_policy(&self) -> Result<i32>

CPUSchedulingPolicy property

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

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

pub fn receive_cpu_scheduling_policy_changed( &self, ) -> PropertyIterator<'p, <Result<i32> as ResultAdapter>::Ok>

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

pub fn cpu_scheduling_priority(&self) -> Result<i32>

CPUSchedulingPriority property

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

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

pub fn receive_cpu_scheduling_priority_changed( &self, ) -> PropertyIterator<'p, <Result<i32> as ResultAdapter>::Ok>

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

pub fn cpu_scheduling_reset_on_fork(&self) -> Result<bool>

CPUSchedulingResetOnFork property

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

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

pub fn receive_cpu_scheduling_reset_on_fork_changed( &self, ) -> PropertyIterator<'p, <Result<bool> as ResultAdapter>::Ok>

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

pub fn cpu_shares(&self) -> Result<u64>

CPUShares property

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

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

pub fn receive_cpu_shares_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn cpu_usage_nsec(&self) -> Result<u64>

CPUUsageNSec property

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

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

pub fn receive_cpu_usage_nsec_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn cpu_weight(&self) -> Result<u64>

CPUWeight property

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

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

pub fn receive_cpu_weight_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

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

CacheDirectory property

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

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

pub fn receive_cache_directory_changed( &self, ) -> PropertyIterator<'p, <Result<Vec<String>> as ResultAdapter>::Ok>

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

pub fn cache_directory_mode(&self) -> Result<u32>

CacheDirectoryMode property

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

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

pub fn receive_cache_directory_mode_changed( &self, ) -> PropertyIterator<'p, <Result<u32> as ResultAdapter>::Ok>

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

pub fn cache_directory_symlink(&self) -> Result<Vec<DirectorySymlink>>

CacheDirectorySymlink property

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

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

pub fn receive_cache_directory_symlink_changed( &self, ) -> PropertyIterator<'p, <Result<Vec<DirectorySymlink>> as ResultAdapter>::Ok>

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

pub fn capability_bounding_set(&self) -> Result<u64>

CapabilityBoundingSet property

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

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

pub fn receive_capability_bounding_set_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn clean_result(&self) -> Result<String>

CleanResult property

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

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

pub fn receive_clean_result_changed( &self, ) -> PropertyIterator<'p, <Result<String> as ResultAdapter>::Ok>

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

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

ConfigurationDirectory property

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

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

pub fn receive_configuration_directory_changed( &self, ) -> PropertyIterator<'p, <Result<Vec<String>> as ResultAdapter>::Ok>

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

pub fn configuration_directory_mode(&self) -> Result<u32>

ConfigurationDirectoryMode property

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

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

pub fn receive_configuration_directory_mode_changed( &self, ) -> PropertyIterator<'p, <Result<u32> as ResultAdapter>::Ok>

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

pub fn control_group(&self) -> Result<String>

ControlGroup property

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

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

pub fn receive_control_group_changed( &self, ) -> PropertyIterator<'p, <Result<String> as ResultAdapter>::Ok>

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

pub fn control_group_id(&self) -> Result<u64>

ControlGroupId property

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

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

pub fn receive_control_group_id_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn control_pid(&self) -> Result<u32>

ControlPID property

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

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

pub fn receive_control_pid_changed( &self, ) -> PropertyIterator<'p, <Result<u32> as ResultAdapter>::Ok>

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

pub fn coredump_filter(&self) -> Result<u64>

CoredumpFilter property

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

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

pub fn receive_coredump_filter_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn default_memory_low(&self) -> Result<u64>

DefaultMemoryLow property

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

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

pub fn receive_default_memory_low_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn default_memory_min(&self) -> Result<u64>

DefaultMemoryMin property

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

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

pub fn receive_default_memory_min_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn delegate(&self) -> Result<bool>

Delegate property

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

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

pub fn receive_delegate_changed( &self, ) -> PropertyIterator<'p, <Result<bool> as ResultAdapter>::Ok>

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

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

DelegateControllers property

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

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

pub fn receive_delegate_controllers_changed( &self, ) -> PropertyIterator<'p, <Result<Vec<String>> as ResultAdapter>::Ok>

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

pub fn device_allow(&self) -> Result<Vec<(String, String)>>

DeviceAllow property

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

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

pub fn receive_device_allow_changed( &self, ) -> PropertyIterator<'p, <Result<Vec<(String, String)>> as ResultAdapter>::Ok>

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

pub fn device_policy(&self) -> Result<String>

DevicePolicy property

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

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

pub fn receive_device_policy_changed( &self, ) -> PropertyIterator<'p, <Result<String> as ResultAdapter>::Ok>

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

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

DisableControllers property

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

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

pub fn receive_disable_controllers_changed( &self, ) -> PropertyIterator<'p, <Result<Vec<String>> as ResultAdapter>::Ok>

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

pub fn dynamic_user(&self) -> Result<bool>

DynamicUser property

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

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

pub fn receive_dynamic_user_changed( &self, ) -> PropertyIterator<'p, <Result<bool> as ResultAdapter>::Ok>

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

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

EffectiveCPUs property

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

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

pub fn receive_effective_cpus_changed( &self, ) -> PropertyIterator<'p, <Result<Vec<u8>> as ResultAdapter>::Ok>

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

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

EffectiveMemoryNodes property

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

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

pub fn receive_effective_memory_nodes_changed( &self, ) -> PropertyIterator<'p, <Result<Vec<u8>> as ResultAdapter>::Ok>

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

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

Environment property

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

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

pub fn receive_environment_changed( &self, ) -> PropertyIterator<'p, <Result<Vec<String>> as ResultAdapter>::Ok>

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

pub fn environment_files(&self) -> Result<Vec<(String, bool)>>

EnvironmentFiles property

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

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

pub fn receive_environment_files_changed( &self, ) -> PropertyIterator<'p, <Result<Vec<(String, bool)>> as ResultAdapter>::Ok>

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

pub fn exec_condition(&self) -> Result<Vec<Exec>>

ExecCondition property

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

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

pub fn receive_exec_condition_changed( &self, ) -> PropertyIterator<'p, <Result<Vec<Exec>> as ResultAdapter>::Ok>

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

pub fn exec_condition_ex(&self) -> Result<Vec<ExecEx>>

ExecConditionEx property

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

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

pub fn receive_exec_condition_ex_changed( &self, ) -> PropertyIterator<'p, <Result<Vec<ExecEx>> as ResultAdapter>::Ok>

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

pub fn exec_main_code(&self) -> Result<i32>

ExecMainCode property

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

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

pub fn receive_exec_main_code_changed( &self, ) -> PropertyIterator<'p, <Result<i32> as ResultAdapter>::Ok>

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

pub fn exec_main_exit_timestamp(&self) -> Result<u64>

ExecMainExitTimestamp property

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

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

pub fn receive_exec_main_exit_timestamp_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn exec_main_exit_timestamp_monotonic(&self) -> Result<u64>

ExecMainExitTimestampMonotonic property

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

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

pub fn receive_exec_main_exit_timestamp_monotonic_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn exec_main_pid(&self) -> Result<u32>

ExecMainPID property

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

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

pub fn receive_exec_main_pid_changed( &self, ) -> PropertyIterator<'p, <Result<u32> as ResultAdapter>::Ok>

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

pub fn exec_main_start_timestamp(&self) -> Result<u64>

ExecMainStartTimestamp property

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

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

pub fn receive_exec_main_start_timestamp_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn exec_main_start_timestamp_monotonic(&self) -> Result<u64>

ExecMainStartTimestampMonotonic property

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

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

pub fn receive_exec_main_start_timestamp_monotonic_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn exec_main_status(&self) -> Result<i32>

ExecMainStatus property

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

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

pub fn receive_exec_main_status_changed( &self, ) -> PropertyIterator<'p, <Result<i32> as ResultAdapter>::Ok>

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

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

ExecPaths property

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

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

pub fn receive_exec_paths_changed( &self, ) -> PropertyIterator<'p, <Result<Vec<String>> as ResultAdapter>::Ok>

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

pub fn exec_reload(&self) -> Result<Vec<Exec>>

ExecReload property

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

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

pub fn receive_exec_reload_changed( &self, ) -> PropertyIterator<'p, <Result<Vec<Exec>> as ResultAdapter>::Ok>

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

pub fn exec_reload_ex(&self) -> Result<Vec<ExecEx>>

ExecReloadEx property

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

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

pub fn receive_exec_reload_ex_changed( &self, ) -> PropertyIterator<'p, <Result<Vec<ExecEx>> as ResultAdapter>::Ok>

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

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

ExecSearchPath property

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

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

pub fn receive_exec_search_path_changed( &self, ) -> PropertyIterator<'p, <Result<Vec<String>> as ResultAdapter>::Ok>

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

pub fn exec_start(&self) -> Result<Vec<Exec>>

ExecStart property

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

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

pub fn receive_exec_start_changed( &self, ) -> PropertyIterator<'p, <Result<Vec<Exec>> as ResultAdapter>::Ok>

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

pub fn exec_start_ex(&self) -> Result<Vec<ExecEx>>

ExecStartEx property

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

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

pub fn receive_exec_start_ex_changed( &self, ) -> PropertyIterator<'p, <Result<Vec<ExecEx>> as ResultAdapter>::Ok>

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

pub fn exec_start_post(&self) -> Result<Vec<Exec>>

ExecStartPost property

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

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

pub fn receive_exec_start_post_changed( &self, ) -> PropertyIterator<'p, <Result<Vec<Exec>> as ResultAdapter>::Ok>

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

pub fn exec_start_post_ex(&self) -> Result<Vec<ExecEx>>

ExecStartPostEx property

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

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

pub fn receive_exec_start_post_ex_changed( &self, ) -> PropertyIterator<'p, <Result<Vec<ExecEx>> as ResultAdapter>::Ok>

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

pub fn exec_start_pre(&self) -> Result<Vec<Exec>>

ExecStartPre property

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

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

pub fn receive_exec_start_pre_changed( &self, ) -> PropertyIterator<'p, <Result<Vec<Exec>> as ResultAdapter>::Ok>

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

pub fn exec_start_pre_ex(&self) -> Result<Vec<ExecEx>>

ExecStartPreEx property

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

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

pub fn receive_exec_start_pre_ex_changed( &self, ) -> PropertyIterator<'p, <Result<Vec<ExecEx>> as ResultAdapter>::Ok>

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

pub fn exec_stop(&self) -> Result<Vec<Exec>>

ExecStop property

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

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

pub fn receive_exec_stop_changed( &self, ) -> PropertyIterator<'p, <Result<Vec<Exec>> as ResultAdapter>::Ok>

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

pub fn exec_stop_ex(&self) -> Result<Vec<ExecEx>>

ExecStopEx property

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

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

pub fn receive_exec_stop_ex_changed( &self, ) -> PropertyIterator<'p, <Result<Vec<ExecEx>> as ResultAdapter>::Ok>

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

pub fn exec_stop_post(&self) -> Result<Vec<Exec>>

ExecStopPost property

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

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

pub fn receive_exec_stop_post_changed( &self, ) -> PropertyIterator<'p, <Result<Vec<Exec>> as ResultAdapter>::Ok>

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

pub fn exec_stop_post_ex(&self) -> Result<Vec<ExecEx>>

ExecStopPostEx property

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

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

pub fn receive_exec_stop_post_ex_changed( &self, ) -> PropertyIterator<'p, <Result<Vec<ExecEx>> as ResultAdapter>::Ok>

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

pub fn exit_type(&self) -> Result<String>

ExitType property

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

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

pub fn receive_exit_type_changed( &self, ) -> PropertyIterator<'p, <Result<String> as ResultAdapter>::Ok>

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

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

ExtensionDirectories property

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

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

pub fn receive_extension_directories_changed( &self, ) -> PropertyIterator<'p, <Result<Vec<String>> as ResultAdapter>::Ok>

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

pub fn extension_images(&self) -> Result<Vec<ExtensionImage>>

ExtensionImages property

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

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

pub fn receive_extension_images_changed( &self, ) -> PropertyIterator<'p, <Result<Vec<ExtensionImage>> as ResultAdapter>::Ok>

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

pub fn file_descriptor_store_max(&self) -> Result<u32>

FileDescriptorStoreMax property

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

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

pub fn receive_file_descriptor_store_max_changed( &self, ) -> PropertyIterator<'p, <Result<u32> as ResultAdapter>::Ok>

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

pub fn final_kill_signal(&self) -> Result<i32>

FinalKillSignal property

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

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

pub fn receive_final_kill_signal_changed( &self, ) -> PropertyIterator<'p, <Result<i32> as ResultAdapter>::Ok>

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

pub fn gid(&self) -> Result<u32>

GID property

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

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

pub fn receive_gid_changed( &self, ) -> PropertyIterator<'p, <Result<u32> as ResultAdapter>::Ok>

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

pub fn group(&self) -> Result<String>

Group property

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

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

pub fn receive_group_changed( &self, ) -> PropertyIterator<'p, <Result<String> as ResultAdapter>::Ok>

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

pub fn guess_main_pid(&self) -> Result<bool>

GuessMainPID property

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

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

pub fn receive_guess_main_pid_changed( &self, ) -> PropertyIterator<'p, <Result<bool> as ResultAdapter>::Ok>

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

pub fn io_accounting(&self) -> Result<bool>

IOAccounting property

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

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

pub fn receive_io_accounting_changed( &self, ) -> PropertyIterator<'p, <Result<bool> as ResultAdapter>::Ok>

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

pub fn io_device_latency_target_usec(&self) -> Result<Vec<(String, u64)>>

IODeviceLatencyTargetUSec property

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

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

pub fn receive_io_device_latency_target_usec_changed( &self, ) -> PropertyIterator<'p, <Result<Vec<(String, u64)>> as ResultAdapter>::Ok>

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

pub fn io_device_weight(&self) -> Result<Vec<(String, u64)>>

IODeviceWeight property

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

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

pub fn receive_io_device_weight_changed( &self, ) -> PropertyIterator<'p, <Result<Vec<(String, u64)>> as ResultAdapter>::Ok>

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

pub fn io_read_bandwidth_max(&self) -> Result<Vec<(String, u64)>>

IOReadBandwidthMax property

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

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

pub fn receive_io_read_bandwidth_max_changed( &self, ) -> PropertyIterator<'p, <Result<Vec<(String, u64)>> as ResultAdapter>::Ok>

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

pub fn io_read_bytes(&self) -> Result<u64>

IOReadBytes property

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

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

pub fn receive_io_read_bytes_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn io_read_iops_max(&self) -> Result<Vec<(String, u64)>>

IOReadIOPSMax property

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

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

pub fn receive_io_read_iops_max_changed( &self, ) -> PropertyIterator<'p, <Result<Vec<(String, u64)>> as ResultAdapter>::Ok>

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

pub fn io_read_operations(&self) -> Result<u64>

IOReadOperations property

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

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

pub fn receive_io_read_operations_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn io_scheduling_class(&self) -> Result<i32>

IOSchedulingClass property

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

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

pub fn receive_io_scheduling_class_changed( &self, ) -> PropertyIterator<'p, <Result<i32> as ResultAdapter>::Ok>

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

pub fn io_scheduling_priority(&self) -> Result<i32>

IOSchedulingPriority property

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

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

pub fn receive_io_scheduling_priority_changed( &self, ) -> PropertyIterator<'p, <Result<i32> as ResultAdapter>::Ok>

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

pub fn io_weight(&self) -> Result<u64>

IOWeight property

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

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

pub fn receive_io_weight_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn io_write_bandwidth_max(&self) -> Result<Vec<(String, u64)>>

IOWriteBandwidthMax property

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

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

pub fn receive_io_write_bandwidth_max_changed( &self, ) -> PropertyIterator<'p, <Result<Vec<(String, u64)>> as ResultAdapter>::Ok>

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

pub fn io_write_bytes(&self) -> Result<u64>

IOWriteBytes property

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

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

pub fn receive_io_write_bytes_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn io_write_iops_max(&self) -> Result<Vec<(String, u64)>>

IOWriteIOPSMax property

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

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

pub fn receive_io_write_iops_max_changed( &self, ) -> PropertyIterator<'p, <Result<Vec<(String, u64)>> as ResultAdapter>::Ok>

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

pub fn io_write_operations(&self) -> Result<u64>

IOWriteOperations property

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

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

pub fn receive_io_write_operations_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn ip_accounting(&self) -> Result<bool>

IPAccounting property

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

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

pub fn receive_ip_accounting_changed( &self, ) -> PropertyIterator<'p, <Result<bool> as ResultAdapter>::Ok>

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

pub fn ip_address_allow(&self) -> Result<Vec<(i32, Vec<u8>, u32)>>

IPAddressAllow property

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

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

pub fn receive_ip_address_allow_changed( &self, ) -> PropertyIterator<'p, <Result<Vec<(i32, Vec<u8>, u32)>> as ResultAdapter>::Ok>

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

pub fn ip_address_deny(&self) -> Result<Vec<(i32, Vec<u8>, u32)>>

IPAddressDeny property

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

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

pub fn receive_ip_address_deny_changed( &self, ) -> PropertyIterator<'p, <Result<Vec<(i32, Vec<u8>, u32)>> as ResultAdapter>::Ok>

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

pub fn ipc_namespace_path(&self) -> Result<String>

IPCNamespacePath property

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

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

pub fn receive_ipc_namespace_path_changed( &self, ) -> PropertyIterator<'p, <Result<String> as ResultAdapter>::Ok>

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

pub fn ip_egress_bytes(&self) -> Result<u64>

IPEgressBytes property

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

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

pub fn receive_ip_egress_bytes_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

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

IPEgressFilterPath property

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

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

pub fn receive_ip_egress_filter_path_changed( &self, ) -> PropertyIterator<'p, <Result<Vec<String>> as ResultAdapter>::Ok>

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

pub fn ip_egress_packets(&self) -> Result<u64>

IPEgressPackets property

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

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

pub fn receive_ip_egress_packets_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn ip_ingress_bytes(&self) -> Result<u64>

IPIngressBytes property

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

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

pub fn receive_ip_ingress_bytes_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

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

IPIngressFilterPath property

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

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

pub fn receive_ip_ingress_filter_path_changed( &self, ) -> PropertyIterator<'p, <Result<Vec<String>> as ResultAdapter>::Ok>

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

pub fn ip_ingress_packets(&self) -> Result<u64>

IPIngressPackets property

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

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

pub fn receive_ip_ingress_packets_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn ignore_sigpipe(&self) -> Result<bool>

IgnoreSIGPIPE property

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

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

pub fn receive_ignore_sigpipe_changed( &self, ) -> PropertyIterator<'p, <Result<bool> as ResultAdapter>::Ok>

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

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

InaccessiblePaths property

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

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

pub fn receive_inaccessible_paths_changed( &self, ) -> PropertyIterator<'p, <Result<Vec<String>> as ResultAdapter>::Ok>

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

pub fn keyring_mode(&self) -> Result<String>

KeyringMode property

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

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

pub fn receive_keyring_mode_changed( &self, ) -> PropertyIterator<'p, <Result<String> as ResultAdapter>::Ok>

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

pub fn kill_mode(&self) -> Result<String>

KillMode property

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

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

pub fn receive_kill_mode_changed( &self, ) -> PropertyIterator<'p, <Result<String> as ResultAdapter>::Ok>

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

pub fn kill_signal(&self) -> Result<i32>

KillSignal property

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

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

pub fn receive_kill_signal_changed( &self, ) -> PropertyIterator<'p, <Result<i32> as ResultAdapter>::Ok>

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

pub fn limit_as(&self) -> Result<u64>

LimitAS property

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

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

pub fn receive_limit_as_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn limit_as_soft(&self) -> Result<u64>

LimitASSoft property

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

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

pub fn receive_limit_as_soft_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn limit_core(&self) -> Result<u64>

LimitCORE property

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

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

pub fn receive_limit_core_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn limit_core_soft(&self) -> Result<u64>

LimitCORESoft property

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

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

pub fn receive_limit_core_soft_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn limit_cpu(&self) -> Result<u64>

LimitCPU property

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

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

pub fn receive_limit_cpu_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn limit_cpu_soft(&self) -> Result<u64>

LimitCPUSoft property

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

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

pub fn receive_limit_cpu_soft_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn limit_data(&self) -> Result<u64>

LimitDATA property

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

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

pub fn receive_limit_data_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn limit_data_soft(&self) -> Result<u64>

LimitDATASoft property

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

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

pub fn receive_limit_data_soft_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn limit_fsize(&self) -> Result<u64>

LimitFSIZE property

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

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

pub fn receive_limit_fsize_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn limit_fsize_soft(&self) -> Result<u64>

LimitFSIZESoft property

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

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

pub fn receive_limit_fsize_soft_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn limit_locks(&self) -> Result<u64>

LimitLOCKS property

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

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

pub fn receive_limit_locks_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn limit_locks_soft(&self) -> Result<u64>

LimitLOCKSSoft property

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

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

pub fn receive_limit_locks_soft_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn limit_memlock(&self) -> Result<u64>

LimitMEMLOCK property

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

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

pub fn receive_limit_memlock_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn limit_memlock_soft(&self) -> Result<u64>

LimitMEMLOCKSoft property

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

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

pub fn receive_limit_memlock_soft_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn limit_msgqueue(&self) -> Result<u64>

LimitMSGQUEUE property

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

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

pub fn receive_limit_msgqueue_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn limit_msgqueue_soft(&self) -> Result<u64>

LimitMSGQUEUESoft property

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

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

pub fn receive_limit_msgqueue_soft_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn limit_nice(&self) -> Result<u64>

LimitNICE property

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

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

pub fn receive_limit_nice_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn limit_nice_soft(&self) -> Result<u64>

LimitNICESoft property

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

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

pub fn receive_limit_nice_soft_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn limit_nofile(&self) -> Result<u64>

LimitNOFILE property

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

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

pub fn receive_limit_nofile_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn limit_nofile_soft(&self) -> Result<u64>

LimitNOFILESoft property

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

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

pub fn receive_limit_nofile_soft_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn limit_nproc(&self) -> Result<u64>

LimitNPROC property

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

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

pub fn receive_limit_nproc_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn limit_nproc_soft(&self) -> Result<u64>

LimitNPROCSoft property

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

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

pub fn receive_limit_nproc_soft_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn limit_rss(&self) -> Result<u64>

LimitRSS property

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

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

pub fn receive_limit_rss_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn limit_rss_soft(&self) -> Result<u64>

LimitRSSSoft property

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

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

pub fn receive_limit_rss_soft_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn limit_rtprio(&self) -> Result<u64>

LimitRTPRIO property

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

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

pub fn receive_limit_rtprio_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn limit_rtprio_soft(&self) -> Result<u64>

LimitRTPRIOSoft property

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

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

pub fn receive_limit_rtprio_soft_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn limit_rttime(&self) -> Result<u64>

LimitRTTIME property

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

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

pub fn receive_limit_rttime_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn limit_rttime_soft(&self) -> Result<u64>

LimitRTTIMESoft property

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

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

pub fn receive_limit_rttime_soft_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn limit_sigpending(&self) -> Result<u64>

LimitSIGPENDING property

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

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

pub fn receive_limit_sigpending_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn limit_sigpending_soft(&self) -> Result<u64>

LimitSIGPENDINGSoft property

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

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

pub fn receive_limit_sigpending_soft_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn limit_stack(&self) -> Result<u64>

LimitSTACK property

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

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

pub fn receive_limit_stack_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn limit_stack_soft(&self) -> Result<u64>

LimitSTACKSoft property

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

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

pub fn receive_limit_stack_soft_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn load_credential(&self) -> Result<Vec<(String, String)>>

LoadCredential property

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

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

pub fn receive_load_credential_changed( &self, ) -> PropertyIterator<'p, <Result<Vec<(String, String)>> as ResultAdapter>::Ok>

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

pub fn load_credential_encrypted(&self) -> Result<Vec<(String, String)>>

LoadCredentialEncrypted property

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

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

pub fn receive_load_credential_encrypted_changed( &self, ) -> PropertyIterator<'p, <Result<Vec<(String, String)>> as ResultAdapter>::Ok>

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

pub fn lock_personality(&self) -> Result<bool>

LockPersonality property

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

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

pub fn receive_lock_personality_changed( &self, ) -> PropertyIterator<'p, <Result<bool> as ResultAdapter>::Ok>

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

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

LogExtraFields property

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

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

pub fn receive_log_extra_fields_changed( &self, ) -> PropertyIterator<'p, <Result<Vec<Vec<u8>>> as ResultAdapter>::Ok>

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

pub fn log_level_max(&self) -> Result<i32>

LogLevelMax property

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

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

pub fn receive_log_level_max_changed( &self, ) -> PropertyIterator<'p, <Result<i32> as ResultAdapter>::Ok>

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

pub fn log_namespace(&self) -> Result<String>

LogNamespace property

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

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

pub fn receive_log_namespace_changed( &self, ) -> PropertyIterator<'p, <Result<String> as ResultAdapter>::Ok>

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

pub fn log_rate_limit_burst(&self) -> Result<u32>

LogRateLimitBurst property

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

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

pub fn receive_log_rate_limit_burst_changed( &self, ) -> PropertyIterator<'p, <Result<u32> as ResultAdapter>::Ok>

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

pub fn log_rate_limit_interval_usec(&self) -> Result<u64>

LogRateLimitIntervalUSec property

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

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

pub fn receive_log_rate_limit_interval_usec_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

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

LogsDirectory property

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

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

pub fn receive_logs_directory_changed( &self, ) -> PropertyIterator<'p, <Result<Vec<String>> as ResultAdapter>::Ok>

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

pub fn logs_directory_mode(&self) -> Result<u32>

LogsDirectoryMode property

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

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

pub fn receive_logs_directory_mode_changed( &self, ) -> PropertyIterator<'p, <Result<u32> as ResultAdapter>::Ok>

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

pub fn logs_directory_symlink(&self) -> Result<Vec<DirectorySymlink>>

LogsDirectorySymlink property

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

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

pub fn receive_logs_directory_symlink_changed( &self, ) -> PropertyIterator<'p, <Result<Vec<DirectorySymlink>> as ResultAdapter>::Ok>

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

pub fn main_pid(&self) -> Result<u32>

MainPID property

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

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

pub fn receive_main_pid_changed( &self, ) -> PropertyIterator<'p, <Result<u32> as ResultAdapter>::Ok>

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

pub fn managed_oom_memory_pressure(&self) -> Result<String>

ManagedOOMMemoryPressure property

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

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

pub fn receive_managed_oom_memory_pressure_changed( &self, ) -> PropertyIterator<'p, <Result<String> as ResultAdapter>::Ok>

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

pub fn managed_oom_memory_pressure_limit(&self) -> Result<u32>

ManagedOOMMemoryPressureLimit property

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

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

pub fn receive_managed_oom_memory_pressure_limit_changed( &self, ) -> PropertyIterator<'p, <Result<u32> as ResultAdapter>::Ok>

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

pub fn managed_oom_preference(&self) -> Result<String>

ManagedOOMPreference property

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

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

pub fn receive_managed_oom_preference_changed( &self, ) -> PropertyIterator<'p, <Result<String> as ResultAdapter>::Ok>

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

pub fn managed_oom_swap(&self) -> Result<String>

ManagedOOMSwap property

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

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

pub fn receive_managed_oom_swap_changed( &self, ) -> PropertyIterator<'p, <Result<String> as ResultAdapter>::Ok>

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

pub fn memory_accounting(&self) -> Result<bool>

MemoryAccounting property

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

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

pub fn receive_memory_accounting_changed( &self, ) -> PropertyIterator<'p, <Result<bool> as ResultAdapter>::Ok>

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

pub fn memory_available(&self) -> Result<u64>

MemoryAvailable property

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

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

pub fn receive_memory_available_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn memory_current(&self) -> Result<u64>

MemoryCurrent property

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

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

pub fn receive_memory_current_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn memory_deny_write_execute(&self) -> Result<bool>

MemoryDenyWriteExecute property

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

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

pub fn receive_memory_deny_write_execute_changed( &self, ) -> PropertyIterator<'p, <Result<bool> as ResultAdapter>::Ok>

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

pub fn memory_high(&self) -> Result<u64>

MemoryHigh property

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

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

pub fn receive_memory_high_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn memory_limit(&self) -> Result<u64>

MemoryLimit property

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

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

pub fn receive_memory_limit_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn memory_low(&self) -> Result<u64>

MemoryLow property

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

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

pub fn receive_memory_low_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn memory_max(&self) -> Result<u64>

MemoryMax property

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

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

pub fn receive_memory_max_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn memory_min(&self) -> Result<u64>

MemoryMin property

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

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

pub fn receive_memory_min_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn memory_swap_max(&self) -> Result<u64>

MemorySwapMax property

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

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

pub fn receive_memory_swap_max_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn mount_apivfs(&self) -> Result<bool>

MountAPIVFS property

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

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

pub fn receive_mount_apivfs_changed( &self, ) -> PropertyIterator<'p, <Result<bool> as ResultAdapter>::Ok>

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

pub fn mount_flags(&self) -> Result<u64>

MountFlags property

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

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

pub fn receive_mount_flags_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn mount_images(&self) -> Result<Vec<MountImage>>

MountImages property

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

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

pub fn receive_mount_images_changed( &self, ) -> PropertyIterator<'p, <Result<Vec<MountImage>> as ResultAdapter>::Ok>

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

pub fn n_file_descriptor_store(&self) -> Result<u32>

NFileDescriptorStore property

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

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

pub fn receive_n_file_descriptor_store_changed( &self, ) -> PropertyIterator<'p, <Result<u32> as ResultAdapter>::Ok>

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

pub fn n_restarts(&self) -> Result<u32>

NRestarts property

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

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

pub fn receive_n_restarts_changed( &self, ) -> PropertyIterator<'p, <Result<u32> as ResultAdapter>::Ok>

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

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

NUMAMask property

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

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

pub fn receive_numa_mask_changed( &self, ) -> PropertyIterator<'p, <Result<Vec<u8>> as ResultAdapter>::Ok>

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

pub fn numa_policy(&self) -> Result<i32>

NUMAPolicy property

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

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

pub fn receive_numa_policy_changed( &self, ) -> PropertyIterator<'p, <Result<i32> as ResultAdapter>::Ok>

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

pub fn network_namespace_path(&self) -> Result<String>

NetworkNamespacePath property

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

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

pub fn receive_network_namespace_path_changed( &self, ) -> PropertyIterator<'p, <Result<String> as ResultAdapter>::Ok>

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

pub fn nice(&self) -> Result<i32>

Nice property

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

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

pub fn receive_nice_changed( &self, ) -> PropertyIterator<'p, <Result<i32> as ResultAdapter>::Ok>

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

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

NoExecPaths property

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

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

pub fn receive_no_exec_paths_changed( &self, ) -> PropertyIterator<'p, <Result<Vec<String>> as ResultAdapter>::Ok>

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

pub fn no_new_privileges(&self) -> Result<bool>

NoNewPrivileges property

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

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

pub fn receive_no_new_privileges_changed( &self, ) -> PropertyIterator<'p, <Result<bool> as ResultAdapter>::Ok>

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

pub fn non_blocking(&self) -> Result<bool>

NonBlocking property

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

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

pub fn receive_non_blocking_changed( &self, ) -> PropertyIterator<'p, <Result<bool> as ResultAdapter>::Ok>

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

pub fn notify_access(&self) -> Result<String>

NotifyAccess property

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

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

pub fn receive_notify_access_changed( &self, ) -> PropertyIterator<'p, <Result<String> as ResultAdapter>::Ok>

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

pub fn oom_policy(&self) -> Result<String>

OOMPolicy property

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

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

pub fn receive_oom_policy_changed( &self, ) -> PropertyIterator<'p, <Result<String> as ResultAdapter>::Ok>

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

pub fn oom_score_adjust(&self) -> Result<i32>

OOMScoreAdjust property

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

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

pub fn receive_oom_score_adjust_changed( &self, ) -> PropertyIterator<'p, <Result<i32> as ResultAdapter>::Ok>

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

pub fn pam_name(&self) -> Result<String>

PAMName property

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

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

pub fn receive_pam_name_changed( &self, ) -> PropertyIterator<'p, <Result<String> as ResultAdapter>::Ok>

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

pub fn pid_file(&self) -> Result<String>

PIDFile property

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

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

pub fn receive_pid_file_changed( &self, ) -> PropertyIterator<'p, <Result<String> as ResultAdapter>::Ok>

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

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

PassEnvironment property

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

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

pub fn receive_pass_environment_changed( &self, ) -> PropertyIterator<'p, <Result<Vec<String>> as ResultAdapter>::Ok>

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

pub fn personality(&self) -> Result<String>

Personality property

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

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

pub fn receive_personality_changed( &self, ) -> PropertyIterator<'p, <Result<String> as ResultAdapter>::Ok>

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

pub fn private_devices(&self) -> Result<bool>

PrivateDevices property

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

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

pub fn receive_private_devices_changed( &self, ) -> PropertyIterator<'p, <Result<bool> as ResultAdapter>::Ok>

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

pub fn private_ipc(&self) -> Result<bool>

PrivateIPC property

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

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

pub fn receive_private_ipc_changed( &self, ) -> PropertyIterator<'p, <Result<bool> as ResultAdapter>::Ok>

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

pub fn private_mounts(&self) -> Result<bool>

PrivateMounts property

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

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

pub fn receive_private_mounts_changed( &self, ) -> PropertyIterator<'p, <Result<bool> as ResultAdapter>::Ok>

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

pub fn private_network(&self) -> Result<bool>

PrivateNetwork property

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

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

pub fn receive_private_network_changed( &self, ) -> PropertyIterator<'p, <Result<bool> as ResultAdapter>::Ok>

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

pub fn private_tmp(&self) -> Result<bool>

PrivateTmp property

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

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

pub fn receive_private_tmp_changed( &self, ) -> PropertyIterator<'p, <Result<bool> as ResultAdapter>::Ok>

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

pub fn private_users(&self) -> Result<bool>

PrivateUsers property

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

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

pub fn receive_private_users_changed( &self, ) -> PropertyIterator<'p, <Result<bool> as ResultAdapter>::Ok>

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

pub fn proc_subset(&self) -> Result<String>

ProcSubset property

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

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

pub fn receive_proc_subset_changed( &self, ) -> PropertyIterator<'p, <Result<String> as ResultAdapter>::Ok>

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

pub fn protect_clock(&self) -> Result<bool>

ProtectClock property

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

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

pub fn receive_protect_clock_changed( &self, ) -> PropertyIterator<'p, <Result<bool> as ResultAdapter>::Ok>

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

pub fn protect_control_groups(&self) -> Result<bool>

ProtectControlGroups property

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

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

pub fn receive_protect_control_groups_changed( &self, ) -> PropertyIterator<'p, <Result<bool> as ResultAdapter>::Ok>

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

pub fn protect_home(&self) -> Result<String>

ProtectHome property

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

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

pub fn receive_protect_home_changed( &self, ) -> PropertyIterator<'p, <Result<String> as ResultAdapter>::Ok>

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

pub fn protect_hostname(&self) -> Result<bool>

ProtectHostname property

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

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

pub fn receive_protect_hostname_changed( &self, ) -> PropertyIterator<'p, <Result<bool> as ResultAdapter>::Ok>

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

pub fn protect_kernel_logs(&self) -> Result<bool>

ProtectKernelLogs property

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

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

pub fn receive_protect_kernel_logs_changed( &self, ) -> PropertyIterator<'p, <Result<bool> as ResultAdapter>::Ok>

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

pub fn protect_kernel_modules(&self) -> Result<bool>

ProtectKernelModules property

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

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

pub fn receive_protect_kernel_modules_changed( &self, ) -> PropertyIterator<'p, <Result<bool> as ResultAdapter>::Ok>

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

pub fn protect_kernel_tunables(&self) -> Result<bool>

ProtectKernelTunables property

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

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

pub fn receive_protect_kernel_tunables_changed( &self, ) -> PropertyIterator<'p, <Result<bool> as ResultAdapter>::Ok>

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

pub fn protect_proc(&self) -> Result<String>

ProtectProc property

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

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

pub fn receive_protect_proc_changed( &self, ) -> PropertyIterator<'p, <Result<String> as ResultAdapter>::Ok>

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

pub fn protect_system(&self) -> Result<String>

ProtectSystem property

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

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

pub fn receive_protect_system_changed( &self, ) -> PropertyIterator<'p, <Result<String> as ResultAdapter>::Ok>

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

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

ReadOnlyPaths property

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

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

pub fn receive_read_only_paths_changed( &self, ) -> PropertyIterator<'p, <Result<Vec<String>> as ResultAdapter>::Ok>

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

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

ReadWritePaths property

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

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

pub fn receive_read_write_paths_changed( &self, ) -> PropertyIterator<'p, <Result<Vec<String>> as ResultAdapter>::Ok>

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

pub fn reload_result(&self) -> Result<String>

ReloadResult property

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

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

pub fn receive_reload_result_changed( &self, ) -> PropertyIterator<'p, <Result<String> as ResultAdapter>::Ok>

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

pub fn remain_after_exit(&self) -> Result<bool>

RemainAfterExit property

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

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

pub fn receive_remain_after_exit_changed( &self, ) -> PropertyIterator<'p, <Result<bool> as ResultAdapter>::Ok>

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

pub fn remove_ipc(&self) -> Result<bool>

RemoveIPC property

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

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

pub fn receive_remove_ipc_changed( &self, ) -> PropertyIterator<'p, <Result<bool> as ResultAdapter>::Ok>

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

pub fn restart(&self) -> Result<String>

Restart property

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

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

pub fn receive_restart_changed( &self, ) -> PropertyIterator<'p, <Result<String> as ResultAdapter>::Ok>

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

pub fn restart_force_exit_status(&self) -> Result<(Vec<i32>, Vec<i32>)>

RestartForceExitStatus property

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

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

pub fn receive_restart_force_exit_status_changed( &self, ) -> PropertyIterator<'p, <Result<(Vec<i32>, Vec<i32>)> as ResultAdapter>::Ok>

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

pub fn restart_kill_signal(&self) -> Result<i32>

RestartKillSignal property

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

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

pub fn receive_restart_kill_signal_changed( &self, ) -> PropertyIterator<'p, <Result<i32> as ResultAdapter>::Ok>

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

pub fn restart_prevent_exit_status(&self) -> Result<(Vec<i32>, Vec<i32>)>

RestartPreventExitStatus property

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

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

pub fn receive_restart_prevent_exit_status_changed( &self, ) -> PropertyIterator<'p, <Result<(Vec<i32>, Vec<i32>)> as ResultAdapter>::Ok>

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

pub fn restart_usec(&self) -> Result<u64>

RestartUSec property

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

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

pub fn receive_restart_usec_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn restrict_address_families(&self) -> Result<(bool, Vec<String>)>

RestrictAddressFamilies property

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

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

pub fn receive_restrict_address_families_changed( &self, ) -> PropertyIterator<'p, <Result<(bool, Vec<String>)> as ResultAdapter>::Ok>

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

pub fn restrict_file_systems(&self) -> Result<(bool, Vec<String>)>

RestrictFileSystems property

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

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

pub fn receive_restrict_file_systems_changed( &self, ) -> PropertyIterator<'p, <Result<(bool, Vec<String>)> as ResultAdapter>::Ok>

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

pub fn restrict_namespaces(&self) -> Result<u64>

RestrictNamespaces property

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

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

pub fn receive_restrict_namespaces_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn restrict_network_interfaces(&self) -> Result<(bool, Vec<String>)>

RestrictNetworkInterfaces property

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

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

pub fn receive_restrict_network_interfaces_changed( &self, ) -> PropertyIterator<'p, <Result<(bool, Vec<String>)> as ResultAdapter>::Ok>

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

pub fn restrict_realtime(&self) -> Result<bool>

RestrictRealtime property

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

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

pub fn receive_restrict_realtime_changed( &self, ) -> PropertyIterator<'p, <Result<bool> as ResultAdapter>::Ok>

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

pub fn restrict_suidsgid(&self) -> Result<bool>

RestrictSUIDSGID property

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

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

pub fn receive_restrict_suidsgid_changed( &self, ) -> PropertyIterator<'p, <Result<bool> as ResultAdapter>::Ok>

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

pub fn result(&self) -> Result<String>

Result property

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

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

pub fn receive_result_changed( &self, ) -> PropertyIterator<'p, <Result<String> as ResultAdapter>::Ok>

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

pub fn root_directory(&self) -> Result<String>

RootDirectory property

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

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

pub fn receive_root_directory_changed( &self, ) -> PropertyIterator<'p, <Result<String> as ResultAdapter>::Ok>

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

pub fn root_directory_start_only(&self) -> Result<bool>

RootDirectoryStartOnly property

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

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

pub fn receive_root_directory_start_only_changed( &self, ) -> PropertyIterator<'p, <Result<bool> as ResultAdapter>::Ok>

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

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

RootHash property

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

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

pub fn receive_root_hash_changed( &self, ) -> PropertyIterator<'p, <Result<Vec<u8>> as ResultAdapter>::Ok>

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

pub fn root_hash_path(&self) -> Result<String>

RootHashPath property

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

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

pub fn receive_root_hash_path_changed( &self, ) -> PropertyIterator<'p, <Result<String> as ResultAdapter>::Ok>

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

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

RootHashSignature property

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

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

pub fn receive_root_hash_signature_changed( &self, ) -> PropertyIterator<'p, <Result<Vec<u8>> as ResultAdapter>::Ok>

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

pub fn root_hash_signature_path(&self) -> Result<String>

RootHashSignaturePath property

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

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

pub fn receive_root_hash_signature_path_changed( &self, ) -> PropertyIterator<'p, <Result<String> as ResultAdapter>::Ok>

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

pub fn root_image(&self) -> Result<String>

RootImage property

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

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

pub fn receive_root_image_changed( &self, ) -> PropertyIterator<'p, <Result<String> as ResultAdapter>::Ok>

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

pub fn root_image_options(&self) -> Result<Vec<(String, String)>>

RootImageOptions property

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

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

pub fn receive_root_image_options_changed( &self, ) -> PropertyIterator<'p, <Result<Vec<(String, String)>> as ResultAdapter>::Ok>

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

pub fn root_verity(&self) -> Result<String>

RootVerity property

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

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

pub fn receive_root_verity_changed( &self, ) -> PropertyIterator<'p, <Result<String> as ResultAdapter>::Ok>

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

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

RuntimeDirectory property

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

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

pub fn receive_runtime_directory_changed( &self, ) -> PropertyIterator<'p, <Result<Vec<String>> as ResultAdapter>::Ok>

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

pub fn runtime_directory_mode(&self) -> Result<u32>

RuntimeDirectoryMode property

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

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

pub fn receive_runtime_directory_mode_changed( &self, ) -> PropertyIterator<'p, <Result<u32> as ResultAdapter>::Ok>

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

pub fn runtime_directory_preserve(&self) -> Result<String>

RuntimeDirectoryPreserve property

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

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

pub fn receive_runtime_directory_preserve_changed( &self, ) -> PropertyIterator<'p, <Result<String> as ResultAdapter>::Ok>

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

pub fn runtime_directory_symlink(&self) -> Result<Vec<DirectorySymlink>>

RuntimeDirectorySymlink property

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

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

pub fn receive_runtime_directory_symlink_changed( &self, ) -> PropertyIterator<'p, <Result<Vec<DirectorySymlink>> as ResultAdapter>::Ok>

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

pub fn runtime_max_usec(&self) -> Result<u64>

RuntimeMaxUSec property

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

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

pub fn receive_runtime_max_usec_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn runtime_randomized_extra_usec(&self) -> Result<u64>

RuntimeRandomizedExtraUSec property

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

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

pub fn receive_runtime_randomized_extra_usec_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn selinux_context(&self) -> Result<(bool, String)>

SELinuxContext property

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

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

pub fn receive_selinux_context_changed( &self, ) -> PropertyIterator<'p, <Result<(bool, String)> as ResultAdapter>::Ok>

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

pub fn same_process_group(&self) -> Result<bool>

SameProcessGroup property

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

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

pub fn receive_same_process_group_changed( &self, ) -> PropertyIterator<'p, <Result<bool> as ResultAdapter>::Ok>

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

pub fn secure_bits(&self) -> Result<i32>

SecureBits property

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

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

pub fn receive_secure_bits_changed( &self, ) -> PropertyIterator<'p, <Result<i32> as ResultAdapter>::Ok>

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

pub fn send_sighup(&self) -> Result<bool>

SendSIGHUP property

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

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

pub fn receive_send_sighup_changed( &self, ) -> PropertyIterator<'p, <Result<bool> as ResultAdapter>::Ok>

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

pub fn send_sigkill(&self) -> Result<bool>

SendSIGKILL property

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

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

pub fn receive_send_sigkill_changed( &self, ) -> PropertyIterator<'p, <Result<bool> as ResultAdapter>::Ok>

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

pub fn set_credential(&self) -> Result<Vec<(String, Vec<u8>)>>

SetCredential property

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

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

pub fn receive_set_credential_changed( &self, ) -> PropertyIterator<'p, <Result<Vec<(String, Vec<u8>)>> as ResultAdapter>::Ok>

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

pub fn set_credential_encrypted(&self) -> Result<Vec<(String, Vec<u8>)>>

SetCredentialEncrypted property

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

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

pub fn receive_set_credential_encrypted_changed( &self, ) -> PropertyIterator<'p, <Result<Vec<(String, Vec<u8>)>> as ResultAdapter>::Ok>

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

pub fn slice(&self) -> Result<String>

Slice property

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

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

pub fn receive_slice_changed( &self, ) -> PropertyIterator<'p, <Result<String> as ResultAdapter>::Ok>

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

pub fn smack_process_label(&self) -> Result<(bool, String)>

SmackProcessLabel property

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

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

pub fn receive_smack_process_label_changed( &self, ) -> PropertyIterator<'p, <Result<(bool, String)> as ResultAdapter>::Ok>

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

pub fn socket_bind_allow(&self) -> Result<Vec<(i32, i32, u16, u16)>>

SocketBindAllow property

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

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

pub fn receive_socket_bind_allow_changed( &self, ) -> PropertyIterator<'p, <Result<Vec<(i32, i32, u16, u16)>> as ResultAdapter>::Ok>

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

pub fn socket_bind_deny(&self) -> Result<Vec<(i32, i32, u16, u16)>>

SocketBindDeny property

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

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

pub fn receive_socket_bind_deny_changed( &self, ) -> PropertyIterator<'p, <Result<Vec<(i32, i32, u16, u16)>> as ResultAdapter>::Ok>

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

pub fn standard_error(&self) -> Result<String>

StandardError property

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

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

pub fn receive_standard_error_changed( &self, ) -> PropertyIterator<'p, <Result<String> as ResultAdapter>::Ok>

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

pub fn standard_error_file_descriptor_name(&self) -> Result<String>

StandardErrorFileDescriptorName property

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

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

pub fn receive_standard_error_file_descriptor_name_changed( &self, ) -> PropertyIterator<'p, <Result<String> as ResultAdapter>::Ok>

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

pub fn standard_input(&self) -> Result<String>

StandardInput property

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

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

pub fn receive_standard_input_changed( &self, ) -> PropertyIterator<'p, <Result<String> as ResultAdapter>::Ok>

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

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

StandardInputData property

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

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

pub fn receive_standard_input_data_changed( &self, ) -> PropertyIterator<'p, <Result<Vec<u8>> as ResultAdapter>::Ok>

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

pub fn standard_input_file_descriptor_name(&self) -> Result<String>

StandardInputFileDescriptorName property

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

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

pub fn receive_standard_input_file_descriptor_name_changed( &self, ) -> PropertyIterator<'p, <Result<String> as ResultAdapter>::Ok>

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

pub fn standard_output(&self) -> Result<String>

StandardOutput property

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

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

pub fn receive_standard_output_changed( &self, ) -> PropertyIterator<'p, <Result<String> as ResultAdapter>::Ok>

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

pub fn standard_output_file_descriptor_name(&self) -> Result<String>

StandardOutputFileDescriptorName property

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

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

pub fn receive_standard_output_file_descriptor_name_changed( &self, ) -> PropertyIterator<'p, <Result<String> as ResultAdapter>::Ok>

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

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

StartupAllowedCPUs property

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

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

pub fn receive_startup_allowed_cpus_changed( &self, ) -> PropertyIterator<'p, <Result<Vec<u8>> as ResultAdapter>::Ok>

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

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

StartupAllowedMemoryNodes property

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

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

pub fn receive_startup_allowed_memory_nodes_changed( &self, ) -> PropertyIterator<'p, <Result<Vec<u8>> as ResultAdapter>::Ok>

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

pub fn startup_block_ioweight(&self) -> Result<u64>

StartupBlockIOWeight property

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

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

pub fn receive_startup_block_ioweight_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn startup_cpushares(&self) -> Result<u64>

StartupCPUShares property

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

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

pub fn receive_startup_cpushares_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn startup_cpuweight(&self) -> Result<u64>

StartupCPUWeight property

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

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

pub fn receive_startup_cpuweight_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn startup_ioweight(&self) -> Result<u64>

StartupIOWeight property

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

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

pub fn receive_startup_ioweight_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

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

StateDirectory property

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

Get the cached value of the StateDirectory property, or None if the property is not cached.

pub fn receive_state_directory_changed( &self, ) -> PropertyIterator<'p, <Result<Vec<String>> as ResultAdapter>::Ok>

Create a stream for the StateDirectory property changes. This is a convenient wrapper around zbus::blocking::Proxy::receive_property_changed.

pub fn state_directory_mode(&self) -> Result<u32>

StateDirectoryMode property

pub fn cached_state_directory_mode( &self, ) -> Result<Option<<Result<u32> as ResultAdapter>::Ok>, <Result<u32> as ResultAdapter>::Err>

Get the cached value of the StateDirectoryMode property, or None if the property is not cached.

pub fn receive_state_directory_mode_changed( &self, ) -> PropertyIterator<'p, <Result<u32> as ResultAdapter>::Ok>

Create a stream for the StateDirectoryMode property changes. This is a convenient wrapper around zbus::blocking::Proxy::receive_property_changed.

pub fn state_directory_symlink(&self) -> Result<Vec<DirectorySymlink>>

StateDirectorySymlink property

pub fn cached_state_directory_symlink( &self, ) -> Result<Option<<Result<Vec<DirectorySymlink>> as ResultAdapter>::Ok>, <Result<Vec<DirectorySymlink>> as ResultAdapter>::Err>

Get the cached value of the StateDirectorySymlink property, or None if the property is not cached.

pub fn receive_state_directory_symlink_changed( &self, ) -> PropertyIterator<'p, <Result<Vec<DirectorySymlink>> as ResultAdapter>::Ok>

Create a stream for the StateDirectorySymlink property changes. This is a convenient wrapper around zbus::blocking::Proxy::receive_property_changed.

pub fn status_errno(&self) -> Result<i32>

StatusErrno property

pub fn cached_status_errno( &self, ) -> Result<Option<<Result<i32> as ResultAdapter>::Ok>, <Result<i32> as ResultAdapter>::Err>

Get the cached value of the StatusErrno property, or None if the property is not cached.

pub fn receive_status_errno_changed( &self, ) -> PropertyIterator<'p, <Result<i32> as ResultAdapter>::Ok>

Create a stream for the StatusErrno property changes. This is a convenient wrapper around zbus::blocking::Proxy::receive_property_changed.

pub fn status_text(&self) -> Result<String>

StatusText property

pub fn cached_status_text( &self, ) -> Result<Option<<Result<String> as ResultAdapter>::Ok>, <Result<String> as ResultAdapter>::Err>

Get the cached value of the StatusText property, or None if the property is not cached.

pub fn receive_status_text_changed( &self, ) -> PropertyIterator<'p, <Result<String> as ResultAdapter>::Ok>

Create a stream for the StatusText property changes. This is a convenient wrapper around zbus::blocking::Proxy::receive_property_changed.

pub fn success_exit_status(&self) -> Result<(Vec<i32>, Vec<i32>)>

SuccessExitStatus property

pub fn cached_success_exit_status( &self, ) -> Result<Option<<Result<(Vec<i32>, Vec<i32>)> as ResultAdapter>::Ok>, <Result<(Vec<i32>, Vec<i32>)> as ResultAdapter>::Err>

Get the cached value of the SuccessExitStatus property, or None if the property is not cached.

pub fn receive_success_exit_status_changed( &self, ) -> PropertyIterator<'p, <Result<(Vec<i32>, Vec<i32>)> as ResultAdapter>::Ok>

Create a stream for the SuccessExitStatus property changes. This is a convenient wrapper around zbus::blocking::Proxy::receive_property_changed.

pub fn supplementary_groups(&self) -> Result<Vec<String>>

SupplementaryGroups property

pub fn cached_supplementary_groups( &self, ) -> Result<Option<<Result<Vec<String>> as ResultAdapter>::Ok>, <Result<Vec<String>> as ResultAdapter>::Err>

Get the cached value of the SupplementaryGroups property, or None if the property is not cached.

pub fn receive_supplementary_groups_changed( &self, ) -> PropertyIterator<'p, <Result<Vec<String>> as ResultAdapter>::Ok>

Create a stream for the SupplementaryGroups property changes. This is a convenient wrapper around zbus::blocking::Proxy::receive_property_changed.

pub fn syslog_facility(&self) -> Result<i32>

SyslogFacility property

pub fn cached_syslog_facility( &self, ) -> Result<Option<<Result<i32> as ResultAdapter>::Ok>, <Result<i32> as ResultAdapter>::Err>

Get the cached value of the SyslogFacility property, or None if the property is not cached.

pub fn receive_syslog_facility_changed( &self, ) -> PropertyIterator<'p, <Result<i32> as ResultAdapter>::Ok>

Create a stream for the SyslogFacility property changes. This is a convenient wrapper around zbus::blocking::Proxy::receive_property_changed.

pub fn syslog_identifier(&self) -> Result<String>

SyslogIdentifier property

pub fn cached_syslog_identifier( &self, ) -> Result<Option<<Result<String> as ResultAdapter>::Ok>, <Result<String> as ResultAdapter>::Err>

Get the cached value of the SyslogIdentifier property, or None if the property is not cached.

pub fn receive_syslog_identifier_changed( &self, ) -> PropertyIterator<'p, <Result<String> as ResultAdapter>::Ok>

Create a stream for the SyslogIdentifier property changes. This is a convenient wrapper around zbus::blocking::Proxy::receive_property_changed.

pub fn syslog_level(&self) -> Result<i32>

SyslogLevel property

pub fn cached_syslog_level( &self, ) -> Result<Option<<Result<i32> as ResultAdapter>::Ok>, <Result<i32> as ResultAdapter>::Err>

Get the cached value of the SyslogLevel property, or None if the property is not cached.

pub fn receive_syslog_level_changed( &self, ) -> PropertyIterator<'p, <Result<i32> as ResultAdapter>::Ok>

Create a stream for the SyslogLevel property changes. This is a convenient wrapper around zbus::blocking::Proxy::receive_property_changed.

pub fn syslog_level_prefix(&self) -> Result<bool>

SyslogLevelPrefix property

pub fn cached_syslog_level_prefix( &self, ) -> Result<Option<<Result<bool> as ResultAdapter>::Ok>, <Result<bool> as ResultAdapter>::Err>

Get the cached value of the SyslogLevelPrefix property, or None if the property is not cached.

pub fn receive_syslog_level_prefix_changed( &self, ) -> PropertyIterator<'p, <Result<bool> as ResultAdapter>::Ok>

Create a stream for the SyslogLevelPrefix property changes. This is a convenient wrapper around zbus::blocking::Proxy::receive_property_changed.

pub fn syslog_priority(&self) -> Result<i32>

SyslogPriority property

pub fn cached_syslog_priority( &self, ) -> Result<Option<<Result<i32> as ResultAdapter>::Ok>, <Result<i32> as ResultAdapter>::Err>

Get the cached value of the SyslogPriority property, or None if the property is not cached.

pub fn receive_syslog_priority_changed( &self, ) -> PropertyIterator<'p, <Result<i32> as ResultAdapter>::Ok>

Create a stream for the SyslogPriority property changes. This is a convenient wrapper around zbus::blocking::Proxy::receive_property_changed.

pub fn system_call_architectures(&self) -> Result<Vec<String>>

SystemCallArchitectures property

pub fn cached_system_call_architectures( &self, ) -> Result<Option<<Result<Vec<String>> as ResultAdapter>::Ok>, <Result<Vec<String>> as ResultAdapter>::Err>

Get the cached value of the SystemCallArchitectures property, or None if the property is not cached.

pub fn receive_system_call_architectures_changed( &self, ) -> PropertyIterator<'p, <Result<Vec<String>> as ResultAdapter>::Ok>

Create a stream for the SystemCallArchitectures property changes. This is a convenient wrapper around zbus::blocking::Proxy::receive_property_changed.

pub fn system_call_error_number(&self) -> Result<i32>

SystemCallErrorNumber property

pub fn cached_system_call_error_number( &self, ) -> Result<Option<<Result<i32> as ResultAdapter>::Ok>, <Result<i32> as ResultAdapter>::Err>

Get the cached value of the SystemCallErrorNumber property, or None if the property is not cached.

pub fn receive_system_call_error_number_changed( &self, ) -> PropertyIterator<'p, <Result<i32> as ResultAdapter>::Ok>

Create a stream for the SystemCallErrorNumber property changes. This is a convenient wrapper around zbus::blocking::Proxy::receive_property_changed.

pub fn system_call_filter(&self) -> Result<(bool, Vec<String>)>

SystemCallFilter property

pub fn cached_system_call_filter( &self, ) -> Result<Option<<Result<(bool, Vec<String>)> as ResultAdapter>::Ok>, <Result<(bool, Vec<String>)> as ResultAdapter>::Err>

Get the cached value of the SystemCallFilter property, or None if the property is not cached.

pub fn receive_system_call_filter_changed( &self, ) -> PropertyIterator<'p, <Result<(bool, Vec<String>)> as ResultAdapter>::Ok>

Create a stream for the SystemCallFilter property changes. This is a convenient wrapper around zbus::blocking::Proxy::receive_property_changed.

pub fn system_call_log(&self) -> Result<(bool, Vec<String>)>

SystemCallLog property

pub fn cached_system_call_log( &self, ) -> Result<Option<<Result<(bool, Vec<String>)> as ResultAdapter>::Ok>, <Result<(bool, Vec<String>)> as ResultAdapter>::Err>

Get the cached value of the SystemCallLog property, or None if the property is not cached.

pub fn receive_system_call_log_changed( &self, ) -> PropertyIterator<'p, <Result<(bool, Vec<String>)> as ResultAdapter>::Ok>

Create a stream for the SystemCallLog property changes. This is a convenient wrapper around zbus::blocking::Proxy::receive_property_changed.

pub fn tty_columns(&self) -> Result<u16>

TTYColumns property

pub fn cached_tty_columns( &self, ) -> Result<Option<<Result<u16> as ResultAdapter>::Ok>, <Result<u16> as ResultAdapter>::Err>

Get the cached value of the TTYColumns property, or None if the property is not cached.

pub fn receive_tty_columns_changed( &self, ) -> PropertyIterator<'p, <Result<u16> as ResultAdapter>::Ok>

Create a stream for the TTYColumns property changes. This is a convenient wrapper around zbus::blocking::Proxy::receive_property_changed.

pub fn tty_path(&self) -> Result<String>

TTYPath property

pub fn cached_tty_path( &self, ) -> Result<Option<<Result<String> as ResultAdapter>::Ok>, <Result<String> as ResultAdapter>::Err>

Get the cached value of the TTYPath property, or None if the property is not cached.

pub fn receive_tty_path_changed( &self, ) -> PropertyIterator<'p, <Result<String> as ResultAdapter>::Ok>

Create a stream for the TTYPath property changes. This is a convenient wrapper around zbus::blocking::Proxy::receive_property_changed.

pub fn tty_reset(&self) -> Result<bool>

TTYReset property

pub fn cached_tty_reset( &self, ) -> Result<Option<<Result<bool> as ResultAdapter>::Ok>, <Result<bool> as ResultAdapter>::Err>

Get the cached value of the TTYReset property, or None if the property is not cached.

pub fn receive_tty_reset_changed( &self, ) -> PropertyIterator<'p, <Result<bool> as ResultAdapter>::Ok>

Create a stream for the TTYReset property changes. This is a convenient wrapper around zbus::blocking::Proxy::receive_property_changed.

pub fn tty_rows(&self) -> Result<u16>

TTYRows property

pub fn cached_tty_rows( &self, ) -> Result<Option<<Result<u16> as ResultAdapter>::Ok>, <Result<u16> as ResultAdapter>::Err>

Get the cached value of the TTYRows property, or None if the property is not cached.

pub fn receive_tty_rows_changed( &self, ) -> PropertyIterator<'p, <Result<u16> as ResultAdapter>::Ok>

Create a stream for the TTYRows property changes. This is a convenient wrapper around zbus::blocking::Proxy::receive_property_changed.

pub fn tty_vhangup(&self) -> Result<bool>

TTYVHangup property

pub fn cached_tty_vhangup( &self, ) -> Result<Option<<Result<bool> as ResultAdapter>::Ok>, <Result<bool> as ResultAdapter>::Err>

Get the cached value of the TTYVHangup property, or None if the property is not cached.

pub fn receive_tty_vhangup_changed( &self, ) -> PropertyIterator<'p, <Result<bool> as ResultAdapter>::Ok>

Create a stream for the TTYVHangup property changes. This is a convenient wrapper around zbus::blocking::Proxy::receive_property_changed.

pub fn tty_vt_disallocate(&self) -> Result<bool>

TTYVTDisallocate property

pub fn cached_tty_vt_disallocate( &self, ) -> Result<Option<<Result<bool> as ResultAdapter>::Ok>, <Result<bool> as ResultAdapter>::Err>

Get the cached value of the TTYVTDisallocate property, or None if the property is not cached.

pub fn receive_tty_vt_disallocate_changed( &self, ) -> PropertyIterator<'p, <Result<bool> as ResultAdapter>::Ok>

Create a stream for the TTYVTDisallocate property changes. This is a convenient wrapper around zbus::blocking::Proxy::receive_property_changed.

pub fn tasks_accounting(&self) -> Result<bool>

TasksAccounting property

pub fn cached_tasks_accounting( &self, ) -> Result<Option<<Result<bool> as ResultAdapter>::Ok>, <Result<bool> as ResultAdapter>::Err>

Get the cached value of the TasksAccounting property, or None if the property is not cached.

pub fn receive_tasks_accounting_changed( &self, ) -> PropertyIterator<'p, <Result<bool> as ResultAdapter>::Ok>

Create a stream for the TasksAccounting property changes. This is a convenient wrapper around zbus::blocking::Proxy::receive_property_changed.

pub fn tasks_current(&self) -> Result<u64>

TasksCurrent property

pub fn cached_tasks_current( &self, ) -> Result<Option<<Result<u64> as ResultAdapter>::Ok>, <Result<u64> as ResultAdapter>::Err>

Get the cached value of the TasksCurrent property, or None if the property is not cached.

pub fn receive_tasks_current_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

Create a stream for the TasksCurrent property changes. This is a convenient wrapper around zbus::blocking::Proxy::receive_property_changed.

pub fn tasks_max(&self) -> Result<u64>

TasksMax property

pub fn cached_tasks_max( &self, ) -> Result<Option<<Result<u64> as ResultAdapter>::Ok>, <Result<u64> as ResultAdapter>::Err>

Get the cached value of the TasksMax property, or None if the property is not cached.

pub fn receive_tasks_max_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

Create a stream for the TasksMax property changes. This is a convenient wrapper around zbus::blocking::Proxy::receive_property_changed.

pub fn temporary_file_system(&self) -> Result<Vec<(String, String)>>

TemporaryFileSystem property

pub fn cached_temporary_file_system( &self, ) -> Result<Option<<Result<Vec<(String, String)>> as ResultAdapter>::Ok>, <Result<Vec<(String, String)>> as ResultAdapter>::Err>

Get the cached value of the TemporaryFileSystem property, or None if the property is not cached.

pub fn receive_temporary_file_system_changed( &self, ) -> PropertyIterator<'p, <Result<Vec<(String, String)>> as ResultAdapter>::Ok>

Create a stream for the TemporaryFileSystem property changes. This is a convenient wrapper around zbus::blocking::Proxy::receive_property_changed.

pub fn timeout_abort_usec(&self) -> Result<u64>

TimeoutAbortUSec property

pub fn cached_timeout_abort_usec( &self, ) -> Result<Option<<Result<u64> as ResultAdapter>::Ok>, <Result<u64> as ResultAdapter>::Err>

Get the cached value of the TimeoutAbortUSec property, or None if the property is not cached.

pub fn receive_timeout_abort_usec_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

Create a stream for the TimeoutAbortUSec property changes. This is a convenient wrapper around zbus::blocking::Proxy::receive_property_changed.

pub fn timeout_clean_usec(&self) -> Result<u64>

TimeoutCleanUSec property

pub fn cached_timeout_clean_usec( &self, ) -> Result<Option<<Result<u64> as ResultAdapter>::Ok>, <Result<u64> as ResultAdapter>::Err>

Get the cached value of the TimeoutCleanUSec property, or None if the property is not cached.

pub fn receive_timeout_clean_usec_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

Create a stream for the TimeoutCleanUSec property changes. This is a convenient wrapper around zbus::blocking::Proxy::receive_property_changed.

pub fn timeout_start_failure_mode(&self) -> Result<String>

TimeoutStartFailureMode property

pub fn cached_timeout_start_failure_mode( &self, ) -> Result<Option<<Result<String> as ResultAdapter>::Ok>, <Result<String> as ResultAdapter>::Err>

Get the cached value of the TimeoutStartFailureMode property, or None if the property is not cached.

pub fn receive_timeout_start_failure_mode_changed( &self, ) -> PropertyIterator<'p, <Result<String> as ResultAdapter>::Ok>

Create a stream for the TimeoutStartFailureMode property changes. This is a convenient wrapper around zbus::blocking::Proxy::receive_property_changed.

pub fn timeout_start_usec(&self) -> Result<u64>

TimeoutStartUSec property

pub fn cached_timeout_start_usec( &self, ) -> Result<Option<<Result<u64> as ResultAdapter>::Ok>, <Result<u64> as ResultAdapter>::Err>

Get the cached value of the TimeoutStartUSec property, or None if the property is not cached.

pub fn receive_timeout_start_usec_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

Create a stream for the TimeoutStartUSec property changes. This is a convenient wrapper around zbus::blocking::Proxy::receive_property_changed.

pub fn timeout_stop_failure_mode(&self) -> Result<String>

TimeoutStopFailureMode property

pub fn cached_timeout_stop_failure_mode( &self, ) -> Result<Option<<Result<String> as ResultAdapter>::Ok>, <Result<String> as ResultAdapter>::Err>

Get the cached value of the TimeoutStopFailureMode property, or None if the property is not cached.

pub fn receive_timeout_stop_failure_mode_changed( &self, ) -> PropertyIterator<'p, <Result<String> as ResultAdapter>::Ok>

Create a stream for the TimeoutStopFailureMode property changes. This is a convenient wrapper around zbus::blocking::Proxy::receive_property_changed.

pub fn timeout_stop_usec(&self) -> Result<u64>

TimeoutStopUSec property

pub fn cached_timeout_stop_usec( &self, ) -> Result<Option<<Result<u64> as ResultAdapter>::Ok>, <Result<u64> as ResultAdapter>::Err>

Get the cached value of the TimeoutStopUSec property, or None if the property is not cached.

pub fn receive_timeout_stop_usec_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

Create a stream for the TimeoutStopUSec property changes. This is a convenient wrapper around zbus::blocking::Proxy::receive_property_changed.

pub fn timer_slack_nsec(&self) -> Result<u64>

TimerSlackNSec property

pub fn cached_timer_slack_nsec( &self, ) -> Result<Option<<Result<u64> as ResultAdapter>::Ok>, <Result<u64> as ResultAdapter>::Err>

Get the cached value of the TimerSlackNSec property, or None if the property is not cached.

pub fn receive_timer_slack_nsec_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

Create a stream for the TimerSlackNSec property changes. This is a convenient wrapper around zbus::blocking::Proxy::receive_property_changed.

pub fn kind(&self) -> Result<String>

Type property

pub fn cached_kind( &self, ) -> Result<Option<<Result<String> as ResultAdapter>::Ok>, <Result<String> as ResultAdapter>::Err>

Get the cached value of the Kind property, or None if the property is not cached.

pub fn receive_kind_changed( &self, ) -> PropertyIterator<'p, <Result<String> as ResultAdapter>::Ok>

Create a stream for the Kind property changes. This is a convenient wrapper around zbus::blocking::Proxy::receive_property_changed.

pub fn uid(&self) -> Result<u32>

UID property

pub fn cached_uid( &self, ) -> Result<Option<<Result<u32> as ResultAdapter>::Ok>, <Result<u32> as ResultAdapter>::Err>

Get the cached value of the UID property, or None if the property is not cached.

pub fn receive_uid_changed( &self, ) -> PropertyIterator<'p, <Result<u32> as ResultAdapter>::Ok>

Create a stream for the UID property changes. This is a convenient wrapper around zbus::blocking::Proxy::receive_property_changed.

pub fn umask(&self) -> Result<u32>

UMask property

pub fn cached_umask( &self, ) -> Result<Option<<Result<u32> as ResultAdapter>::Ok>, <Result<u32> as ResultAdapter>::Err>

Get the cached value of the UMask property, or None if the property is not cached.

pub fn receive_umask_changed( &self, ) -> PropertyIterator<'p, <Result<u32> as ResultAdapter>::Ok>

Create a stream for the UMask property changes. This is a convenient wrapper around zbus::blocking::Proxy::receive_property_changed.

pub fn usb_function_descriptors(&self) -> Result<String>

USBFunctionDescriptors property

pub fn cached_usb_function_descriptors( &self, ) -> Result<Option<<Result<String> as ResultAdapter>::Ok>, <Result<String> as ResultAdapter>::Err>

Get the cached value of the USBFunctionDescriptors property, or None if the property is not cached.

pub fn receive_usb_function_descriptors_changed( &self, ) -> PropertyIterator<'p, <Result<String> as ResultAdapter>::Ok>

Create a stream for the USBFunctionDescriptors property changes. This is a convenient wrapper around zbus::blocking::Proxy::receive_property_changed.

pub fn usb_function_strings(&self) -> Result<String>

USBFunctionStrings property

pub fn cached_usb_function_strings( &self, ) -> Result<Option<<Result<String> as ResultAdapter>::Ok>, <Result<String> as ResultAdapter>::Err>

Get the cached value of the USBFunctionStrings property, or None if the property is not cached.

pub fn receive_usb_function_strings_changed( &self, ) -> PropertyIterator<'p, <Result<String> as ResultAdapter>::Ok>

Create a stream for the USBFunctionStrings property changes. This is a convenient wrapper around zbus::blocking::Proxy::receive_property_changed.

pub fn unset_environment(&self) -> Result<Vec<String>>

UnsetEnvironment property

pub fn cached_unset_environment( &self, ) -> Result<Option<<Result<Vec<String>> as ResultAdapter>::Ok>, <Result<Vec<String>> as ResultAdapter>::Err>

Get the cached value of the UnsetEnvironment property, or None if the property is not cached.

pub fn receive_unset_environment_changed( &self, ) -> PropertyIterator<'p, <Result<Vec<String>> as ResultAdapter>::Ok>

Create a stream for the UnsetEnvironment property changes. This is a convenient wrapper around zbus::blocking::Proxy::receive_property_changed.

pub fn user(&self) -> Result<String>

User property

pub fn cached_user( &self, ) -> Result<Option<<Result<String> as ResultAdapter>::Ok>, <Result<String> as ResultAdapter>::Err>

Get the cached value of the User property, or None if the property is not cached.

pub fn receive_user_changed( &self, ) -> PropertyIterator<'p, <Result<String> as ResultAdapter>::Ok>

Create a stream for the User property changes. This is a convenient wrapper around zbus::blocking::Proxy::receive_property_changed.

pub fn utmp_identifier(&self) -> Result<String>

UtmpIdentifier property

pub fn cached_utmp_identifier( &self, ) -> Result<Option<<Result<String> as ResultAdapter>::Ok>, <Result<String> as ResultAdapter>::Err>

Get the cached value of the UtmpIdentifier property, or None if the property is not cached.

pub fn receive_utmp_identifier_changed( &self, ) -> PropertyIterator<'p, <Result<String> as ResultAdapter>::Ok>

Create a stream for the UtmpIdentifier property changes. This is a convenient wrapper around zbus::blocking::Proxy::receive_property_changed.

pub fn utmp_mode(&self) -> Result<String>

UtmpMode property

pub fn cached_utmp_mode( &self, ) -> Result<Option<<Result<String> as ResultAdapter>::Ok>, <Result<String> as ResultAdapter>::Err>

Get the cached value of the UtmpMode property, or None if the property is not cached.

pub fn receive_utmp_mode_changed( &self, ) -> PropertyIterator<'p, <Result<String> as ResultAdapter>::Ok>

Create a stream for the UtmpMode property changes. This is a convenient wrapper around zbus::blocking::Proxy::receive_property_changed.

pub fn watchdog_signal(&self) -> Result<i32>

WatchdogSignal property

pub fn cached_watchdog_signal( &self, ) -> Result<Option<<Result<i32> as ResultAdapter>::Ok>, <Result<i32> as ResultAdapter>::Err>

Get the cached value of the WatchdogSignal property, or None if the property is not cached.

pub fn receive_watchdog_signal_changed( &self, ) -> PropertyIterator<'p, <Result<i32> as ResultAdapter>::Ok>

Create a stream for the WatchdogSignal property changes. This is a convenient wrapper around zbus::blocking::Proxy::receive_property_changed.

pub fn watchdog_timestamp(&self) -> Result<u64>

WatchdogTimestamp property

pub fn cached_watchdog_timestamp( &self, ) -> Result<Option<<Result<u64> as ResultAdapter>::Ok>, <Result<u64> as ResultAdapter>::Err>

Get the cached value of the WatchdogTimestamp property, or None if the property is not cached.

pub fn receive_watchdog_timestamp_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

Create a stream for the WatchdogTimestamp property changes. This is a convenient wrapper around zbus::blocking::Proxy::receive_property_changed.

pub fn watchdog_timestamp_monotonic(&self) -> Result<u64>

WatchdogTimestampMonotonic property

pub fn cached_watchdog_timestamp_monotonic( &self, ) -> Result<Option<<Result<u64> as ResultAdapter>::Ok>, <Result<u64> as ResultAdapter>::Err>

Get the cached value of the WatchdogTimestampMonotonic property, or None if the property is not cached.

pub fn receive_watchdog_timestamp_monotonic_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

Create a stream for the WatchdogTimestampMonotonic property changes. This is a convenient wrapper around zbus::blocking::Proxy::receive_property_changed.

pub fn watchdog_usec(&self) -> Result<u64>

WatchdogUSec property

pub fn cached_watchdog_usec( &self, ) -> Result<Option<<Result<u64> as ResultAdapter>::Ok>, <Result<u64> as ResultAdapter>::Err>

Get the cached value of the WatchdogUSec property, or None if the property is not cached.

pub fn receive_watchdog_usec_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

Create a stream for the WatchdogUSec property changes. This is a convenient wrapper around zbus::blocking::Proxy::receive_property_changed.

pub fn working_directory(&self) -> Result<String>

WorkingDirectory property

pub fn cached_working_directory( &self, ) -> Result<Option<<Result<String> as ResultAdapter>::Ok>, <Result<String> as ResultAdapter>::Err>

Get the cached value of the WorkingDirectory property, or None if the property is not cached.

pub fn receive_working_directory_changed( &self, ) -> PropertyIterator<'p, <Result<String> as ResultAdapter>::Ok>

Create a stream for the WorkingDirectory property changes. This is a convenient wrapper around zbus::blocking::Proxy::receive_property_changed.

Trait Implementations

impl<'p> AsMut<Proxy<'p>> for ServiceProxyBlocking<'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 ServiceProxyBlocking<'p>

fn as_ref(&self) -> &Proxy<'p>

Converts this type into a shared reference of the (usually inferred) input type.

impl<'p> Clone for ServiceProxyBlocking<'p>

fn clone(&self) -> ServiceProxyBlocking<'p>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'p> Debug for ServiceProxyBlocking<'p>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a> Defaults for ServiceProxyBlocking<'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 ServiceProxyBlocking<'p>

fn from(proxy: Proxy<'p>) -> Self

Converts to this type from the input type.

impl<'p> ProxyImpl<'p> for ServiceProxyBlocking<'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 ServiceProxyBlocking<'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 ServiceProxyBlocking<'p>

const SIGNATURE: &'static Signature

The signature for the implementing type, in parsed format.