Struct SliceProxy

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

Implementations

impl<'p> SliceProxy<'p>

pub async fn new<P>(conn: &Connection, path: P) -> Result<SliceProxy<'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 async fn attach_processes( &self, subcgroup: &str, pids: &[u32], ) -> Result<()>

AttachProcesses method

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

GetProcesses method

pub async 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 async fn receive_allowed_cpus_changed( &self, ) -> PropertyStream<'p, <Result<Vec<u8>> as ResultAdapter>::Ok>

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

pub async 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 async fn receive_allowed_memory_nodes_changed( &self, ) -> PropertyStream<'p, <Result<Vec<u8>> as ResultAdapter>::Ok>

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

pub async 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 async fn receive_bpf_program_changed( &self, ) -> PropertyStream<'p, <Result<Vec<(String, String)>> as ResultAdapter>::Ok>

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

pub async 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 async fn receive_block_io_accounting_changed( &self, ) -> PropertyStream<'p, <Result<bool> as ResultAdapter>::Ok>

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

pub async 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 async fn receive_block_io_device_weight_changed( &self, ) -> PropertyStream<'p, <Result<Vec<(String, u64)>> as ResultAdapter>::Ok>

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

pub async 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 async fn receive_block_io_read_bandwidth_changed( &self, ) -> PropertyStream<'p, <Result<Vec<(String, u64)>> as ResultAdapter>::Ok>

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

pub async 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 async fn receive_block_io_weight_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub async 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 async fn receive_block_io_write_bandwidth_changed( &self, ) -> PropertyStream<'p, <Result<Vec<(String, u64)>> as ResultAdapter>::Ok>

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

pub async 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 async fn receive_cpu_accounting_changed( &self, ) -> PropertyStream<'p, <Result<bool> as ResultAdapter>::Ok>

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

pub async 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 async fn receive_cpu_quota_per_sec_usec_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub async 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 async fn receive_cpu_quota_period_usec_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub async 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 async fn receive_cpu_shares_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub async 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 async fn receive_cpu_usage_nsec_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub async 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 async fn receive_cpu_weight_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub async 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 async fn receive_control_group_changed( &self, ) -> PropertyStream<'p, <Result<String> as ResultAdapter>::Ok>

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

pub async 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 async fn receive_control_group_id_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub async 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 async fn receive_default_memory_low_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub async 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 async fn receive_default_memory_min_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub async 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 async fn receive_delegate_changed( &self, ) -> PropertyStream<'p, <Result<bool> as ResultAdapter>::Ok>

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

pub async 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 async fn receive_delegate_controllers_changed( &self, ) -> PropertyStream<'p, <Result<Vec<String>> as ResultAdapter>::Ok>

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

pub async 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 async fn receive_device_allow_changed( &self, ) -> PropertyStream<'p, <Result<Vec<(String, String)>> as ResultAdapter>::Ok>

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

pub async 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 async fn receive_device_policy_changed( &self, ) -> PropertyStream<'p, <Result<String> as ResultAdapter>::Ok>

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

pub async 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 async fn receive_disable_controllers_changed( &self, ) -> PropertyStream<'p, <Result<Vec<String>> as ResultAdapter>::Ok>

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

pub async 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 async fn receive_effective_cpus_changed( &self, ) -> PropertyStream<'p, <Result<Vec<u8>> as ResultAdapter>::Ok>

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

pub async 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 async fn receive_effective_memory_nodes_changed( &self, ) -> PropertyStream<'p, <Result<Vec<u8>> as ResultAdapter>::Ok>

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

pub async 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 async fn receive_io_accounting_changed( &self, ) -> PropertyStream<'p, <Result<bool> as ResultAdapter>::Ok>

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

pub async 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 async fn receive_io_device_latency_target_usec_changed( &self, ) -> PropertyStream<'p, <Result<Vec<(String, u64)>> as ResultAdapter>::Ok>

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

pub async 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 async fn receive_io_device_weight_changed( &self, ) -> PropertyStream<'p, <Result<Vec<(String, u64)>> as ResultAdapter>::Ok>

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

pub async 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 async fn receive_io_read_bandwidth_max_changed( &self, ) -> PropertyStream<'p, <Result<Vec<(String, u64)>> as ResultAdapter>::Ok>

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

pub async 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 async fn receive_io_read_bytes_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub async 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 async fn receive_io_read_iops_max_changed( &self, ) -> PropertyStream<'p, <Result<Vec<(String, u64)>> as ResultAdapter>::Ok>

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

pub async 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 async fn receive_io_read_operations_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub async 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 async fn receive_io_weight_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub async 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 async fn receive_io_write_bandwidth_max_changed( &self, ) -> PropertyStream<'p, <Result<Vec<(String, u64)>> as ResultAdapter>::Ok>

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

pub async 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 async fn receive_io_write_bytes_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub async 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 async fn receive_io_write_iops_max_changed( &self, ) -> PropertyStream<'p, <Result<Vec<(String, u64)>> as ResultAdapter>::Ok>

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

pub async 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 async fn receive_io_write_operations_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub async 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 async fn receive_ip_accounting_changed( &self, ) -> PropertyStream<'p, <Result<bool> as ResultAdapter>::Ok>

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

pub async 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 async fn receive_ip_address_allow_changed( &self, ) -> PropertyStream<'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::Proxy::receive_property_changed.

pub async 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 async fn receive_ip_address_deny_changed( &self, ) -> PropertyStream<'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::Proxy::receive_property_changed.

pub async 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 async fn receive_ip_egress_bytes_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub async 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 async fn receive_ip_egress_filter_path_changed( &self, ) -> PropertyStream<'p, <Result<Vec<String>> as ResultAdapter>::Ok>

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

pub async 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 async fn receive_ip_egress_packets_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub async 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 async fn receive_ip_ingress_bytes_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub async 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 async fn receive_ip_ingress_filter_path_changed( &self, ) -> PropertyStream<'p, <Result<Vec<String>> as ResultAdapter>::Ok>

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

pub async 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 async fn receive_ip_ingress_packets_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub async 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 async fn receive_managed_oom_memory_pressure_changed( &self, ) -> PropertyStream<'p, <Result<String> as ResultAdapter>::Ok>

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

pub async 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 async fn receive_managed_oom_memory_pressure_limit_changed( &self, ) -> PropertyStream<'p, <Result<u32> as ResultAdapter>::Ok>

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

pub async 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 async fn receive_managed_oom_preference_changed( &self, ) -> PropertyStream<'p, <Result<String> as ResultAdapter>::Ok>

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

pub async 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 async fn receive_managed_oom_swap_changed( &self, ) -> PropertyStream<'p, <Result<String> as ResultAdapter>::Ok>

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

pub async 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 async fn receive_memory_accounting_changed( &self, ) -> PropertyStream<'p, <Result<bool> as ResultAdapter>::Ok>

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

pub async 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 async fn receive_memory_available_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub async 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 async fn receive_memory_current_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub async 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 async fn receive_memory_high_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub async 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 async fn receive_memory_limit_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub async 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 async fn receive_memory_low_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub async 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 async fn receive_memory_max_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub async 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 async fn receive_memory_min_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub async 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 async fn receive_memory_swap_max_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub async 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 async fn receive_restrict_network_interfaces_changed( &self, ) -> PropertyStream<'p, <Result<(bool, Vec<String>)> as ResultAdapter>::Ok>

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

pub async 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 async fn receive_slice_changed( &self, ) -> PropertyStream<'p, <Result<String> as ResultAdapter>::Ok>

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

pub async 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 async fn receive_socket_bind_allow_changed( &self, ) -> PropertyStream<'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::Proxy::receive_property_changed.

pub async 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 async fn receive_socket_bind_deny_changed( &self, ) -> PropertyStream<'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::Proxy::receive_property_changed.

pub async 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 async fn receive_startup_allowed_cpus_changed( &self, ) -> PropertyStream<'p, <Result<Vec<u8>> as ResultAdapter>::Ok>

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

pub async 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 async fn receive_startup_allowed_memory_nodes_changed( &self, ) -> PropertyStream<'p, <Result<Vec<u8>> as ResultAdapter>::Ok>

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

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

StartupBlockIOWeight property

pub fn cached_startup_block_io_weight( &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 async fn receive_startup_block_io_weight_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

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

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

StartupCPUShares property

pub fn cached_startup_cpu_shares( &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 async fn receive_startup_cpu_shares_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

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

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

StartupCPUWeight property

pub fn cached_startup_cpu_weight( &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 async fn receive_startup_cpu_weight_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

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

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

StartupIOWeight property

pub fn cached_startup_io_weight( &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 async fn receive_startup_io_weight_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub async 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 async fn receive_tasks_accounting_changed( &self, ) -> PropertyStream<'p, <Result<bool> as ResultAdapter>::Ok>

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

pub async 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 async fn receive_tasks_current_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub async 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 async fn receive_tasks_max_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

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

Trait Implementations

impl<'p> AsMut<Proxy<'p>> for SliceProxy<'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 SliceProxy<'p>

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

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

impl<'p> Clone for SliceProxy<'p>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'p> Debug for SliceProxy<'p>

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

Formats the value using the given formatter.

impl<'a> Defaults for SliceProxy<'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 SliceProxy<'p>

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

Converts to this type from the input type.

impl<'p> ProxyImpl<'p> for SliceProxy<'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 SliceProxy<'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 SliceProxy<'p>

const SIGNATURE: &'static Signature

The signature for the implementing type, in parsed format.