Enum Name 

#[non_exhaustive]
pub enum Name {
    Abrt,
    Alrm,
    Bus,
    Chld,
    Cld,
    Cont,
    Emt,
    Fpe,
    Hup,
    Ill,
    Info,
    Int,
    Io,
    Iot,
    Kill,
    Lost,
    Pipe,
    Poll,
    Prof,
    Pwr,
    Quit,
    Segv,
    Stkflt,
    Stop,
    Sys,
    Term,
    Thr,
    Trap,
    Tstp,
    Ttin,
    Ttou,
    Urg,
    Usr1,
    Usr2,
    Vtalrm,
    Winch,
    Xcpu,
    Xfsz,
    Rtmin(RawNumber),
    Rtmax(RawNumber),
}

Signal name

This enum identifies a signal by its name. It can be used to represent signals regardless of whether they are available on the System.

Use the System::validate_signal function to obtain a Name from a signal number. The System::signal_number_from_name function can be used to convert a Name to a Number.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Abrt

SIGABRT (process abort signal)

Alrm

SIGALRM (alarm clock)

Bus

SIGBUS (access to an undefined portion of a memory object)

Chld

SIGCHLD (child process terminated, stopped, or continued)

Cld

SIGCLD (child process terminated, stopped, or continued)

Cont

SIGCONT (continue executing, if stopped)

Emt

SIGEMT (emulation trap)

Fpe

SIGFPE (erroneous arithmetic operation)

Hup

SIGHUP (hangup)

Ill

SIGILL (illegal instruction)

Info

SIGINFO (status request from keyboard)

Int

SIGINT (interrupt)

Io

SIGIO (I/O is possible on a file descriptor)

Iot

SIGIOT (I/O trap)

Kill

SIGKILL (kill)

Lost

SIGLOST (resource lost)

Pipe

SIGPIPE (write on a pipe with no one to read it)

Poll

SIGPOLL (pollable event)

Prof

SIGPROF (profiling timer expired)

Pwr

SIGPWR (power failure)

Quit

SIGQUIT (quit)

Segv

SIGSEGV (invalid memory reference)

Stkflt

SIGSTKFLT (stack fault)

Stop

SIGSTOP (stop executing)

Sys

SIGSYS (bad system call)

Term

SIGTERM (termination)

Thr

SIGTHR (thread interrupt)

Trap

SIGTRAP (trace trap)

Tstp

SIGTSTP (stop executing)

Ttin

SIGTTIN (background process attempting read)

Ttou

SIGTTOU (background process attempting write)

Urg

SIGURG (high bandwidth data is available at a socket)

Usr1

SIGUSR1 (user-defined signal 1)

Usr2

SIGUSR2 (user-defined signal 2)

Vtalrm

SIGVTALRM (virtual timer expired)

Winch

SIGWINCH (window size change)

Xcpu

SIGXCPU (CPU time limit exceeded)

Xfsz

SIGXFSZ (file size limit exceeded)

Rtmin(RawNumber)

Real-time signal with a number relative to the minimum real-time signal

Rtmin(n) represents the real-time signal SIGRTMIN + n, where n is expected to be a non-negative integer between 0 and SIGRTMAX - SIGRTMIN.

Rtmax(RawNumber)

Real-time signal with a number relative to the maximum real-time signal

Rtmax(n) represents the real-time signal SIGRTMAX + n, where n is expected to be a non-positive integer between SIGRTMIN - SIGRTMAX and 0.

Implementations

impl Name

pub fn iter() -> NameIter

Returns an iterator over all signal names.

This is a convenience method that returns an iterator over all signal names. The iterator yields all signal names other than Rtmin and Rtmax in the alphabetical order, followed by Rtmin(0) and Rtmax(0) as the last two items.

Note that the iterator works independently of the underlying system and does not check whether the signals are available on the system.

pub fn as_string(&self) -> Cow<'static, str>

Returns the name as a string.

For most signals, this function returns a static string that is the signal name in uppercase without the "SIG" prefix. For real-time signals Rtmin(n) and Rtmax(n) where n is non-zero, this function returns a dynamically allocated string that is RTMIN or RTMAX followed by the relative number n. Examples of the returned strings are "TERM", "RTMIN", and "RTMAX-5".

The returned name can be converted back to the signal using the FromStr implementation for Name.

Trait Implementations

impl Clone for Name

fn clone(&self) -> Name

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Name

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

Formats the value using the given formatter.

impl Display for Name

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

Writes the signal name to the formatter.

See Name::as_string for the format of the produced string.

impl FromStr for Name

Parses a signal name from a string.

This function parses a signal name from a string. The input string is expected to be an uppercase signal name without the "SIG" prefix. The function returns the corresponding signal name if the input string matches a known signal name. Otherwise, it returns an error.

See Name::as_string for the format of the input string.

type Err = UnknownNameError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, UnknownNameError>

Parses a string s to return a value of this type.

impl Hash for Name

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl IntoEnumIterator for Name

type Iterator = NameIter

fn iter() -> NameIter

impl PartialEq for Name

fn eq(&self, other: &Name) -> 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 PartialOrd for Name

Compares two signal names.

The comparison is allowed only between two Rtmin values or two Rtmax values. The comparison is based on the numerical value of the signal number.

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

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

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

Tests less than (for self and other) and is used by the < operator.

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

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

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

Tests greater than (for self and other) and is used by the > operator.

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

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

impl Copy for Name

impl Eq for Name

impl StructuralPartialEq for Name