Struct Limits 

pub struct Limits {

    pub max_cpu_time: Limit,
    pub max_file_size: Limit,
    pub max_data_size: Limit,
    pub max_stack_size: Limit,
    pub max_core_file_size: Limit,
    pub max_resident_set: Limit,
    pub max_processes: Limit,
    pub max_open_files: Limit,
    pub max_locked_memory: Limit,
    pub max_address_space: Limit,
    pub max_file_locks: Limit,
    pub max_pending_signals: Limit,
    pub max_msgqueue_size: Limit,
    pub max_nice_priority: Limit,
    pub max_realtime_priority: Limit,
    pub max_realtime_timeout: Limit,
}

A structure containing all possible properties that can be limited by a GNU/Linux operating system.

Fields

max_cpu_time: Limit

max_file_size: Limit

max_data_size: Limit

max_stack_size: Limit

max_core_file_size: Limit

max_resident_set: Limit

max_processes: Limit

max_open_files: Limit

max_locked_memory: Limit

max_address_space: Limit

max_file_locks: Limit

max_pending_signals: Limit

max_msgqueue_size: Limit

max_nice_priority: Limit

max_realtime_priority: Limit

max_realtime_timeout: Limit

Implementations

impl Limits

pub fn set_property_from_strings( &mut self, name: &str, soft_string: &str, hard_string: &str, )

Set properties on a Limit structure, as read from strings.

Examples

use limits_rs::{Limit, Limits};

// Create a new limits structure
let mut limits = Limits::default();

// Trying to set a non-existing property should do nothing
limits.set_property_from_strings("Does_not_exist", "123", "456");
assert_eq!(limits, Limits::default());

// Let's set a limit for a existing property and assert that the limit is actually stored in
// the structure
limits.set_property_from_strings("Max file locks", "123", "456");
assert_eq!(limits.max_file_locks, Limit { soft: Some(123), hard: Some(456) })

Trait Implementations

impl Debug for Limits

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

Formats the value using the given formatter.

impl Default for Limits

fn default() -> Limits

Returns the “default value” for a type.

impl PartialEq for Limits

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

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for Limits

impl StructuralPartialEq for Limits