Enum SignificanceLevel 

#[repr(u8)]
pub enum SignificanceLevel {
    Test = 0,
    Statement = 1,
    Emergency = 2,
    Watch = 3,
    Warning = 4,
    Unknown = 5,
}

SAME message significance level

Usually constructed as part of an EventCode. See also MessageHeader::event()

Three-letter SAME codes sometimes use the last letter to indicate significance or severity.

Code	Significance
xxT	test
xxS	statement
xxE	emergency
xxA	watch
xxW	warning

There are many message codes which do not follow this standard—and some even contradict it. sameplace knows the correct significance code for these special cases, and the event API will return it.

Significance codes can be converted directly from or to string.

use sameplace::SignificanceLevel;

assert_eq!(SignificanceLevel::Watch, SignificanceLevel::from("A"));
assert_eq!(SignificanceLevel::Test, SignificanceLevel::from("T"));

assert_eq!("Test", SignificanceLevel::Test.as_display_str());
assert_eq!("Test", format!("{}", SignificanceLevel::Test));
assert_eq!("T", SignificanceLevel::Test.as_code_str());
assert_eq!("T", format!("{:#}", SignificanceLevel::Test));

Significance levels are Ord. Lower significance levels represent less urgent messages, such as tests and statements. Higher significance levels represent more important or urgent messages which may merit a “noisy” notification.

assert!(SignificanceLevel::Test < SignificanceLevel::Warning);
assert!(SignificanceLevel::Watch < SignificanceLevel::Warning);

Unrecognized significance levels are quietly represented as SignificanceLevel::Unknown. Clients are encouraged to treat messages with this significance level as a Warning.

assert_eq!(SignificanceLevel::Unknown, SignificanceLevel::from(""));
assert!(SignificanceLevel::Unknown >= SignificanceLevel::Warning);

Variants

Test = 0

Test

A message intended only for testing purposes. “This is only a test.”

Statement = 1

Statement

A message containing follow up information to a warning, watch, or emergency (NWSI 10-1712).

Emergency = 2

Emergency

An event that by itself would not kill or injure or do property damage, but indirectly may cause other things to happen that result in a hazard. Example, a major power or telephone loss in a large city alone is not a direct hazard but disruption to other critical services could create a variety of conditions that could directly threaten public safety (NWSI 10-1712).

Watch = 3

Watch

Meets the classification of a warning, but either the onset time, probability of occurrence, or location is uncertain (NWSI 10-1712).

Warning = 4

Warning (the most severe event)

Those events that alone pose a significant threat to public safety and/or property, probability of occurrence and location is high, and the onset time is relatively short (NWSI 10-1712).

Unknown = 5

Unknown significance level

No significance level could be determined, either by knowledge of the complete event code or by examining the last character. Clients are strongly advised to treat unknown-significance messages as SignificanceLevel::Warning.

Implementations

impl SignificanceLevel

pub fn from<S>(code: S) -> SignificanceLevel

where S: AsRef<str>,

Parse from string

Parses a SAME significance level from a single-character code like “T” for SignificanceLevel::Test. If the input does not match a significance level, returns SignificanceLevel::Unknown.

The user is cautioned not to blindly convert the last character of a SAME code to a SignificanceLevel. There are many event codes like “EVI” which do not follow the SignificanceLevel convention.

pub fn as_display_str(&self) -> &'static str

Human-readable string representation

Converts to a human-readable string, like “Warning.”

pub fn as_code_str(&self) -> &'static str

SAME string representation

Returns the one-character SAME code for this SignificanceLevel. While this is frequently the last character of the event code, there are almost as many exceptions to this rule as there are codes which follow it.

Trait Implementations

impl AsRef<str> for SignificanceLevel

fn as_ref(&self) -> &'static str

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

impl Clone for SignificanceLevel

fn clone(&self) -> SignificanceLevel

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SignificanceLevel

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

Formats the value using the given formatter.

impl Default for SignificanceLevel

fn default() -> SignificanceLevel

Returns the “default value” for a type.

impl Display for SignificanceLevel

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

Printable string

• The normal form is a human-readable string like “Statement”
• The alternate form is a one-character string like “S”

impl EnumMessage for SignificanceLevel

fn get_message(&self) -> Option<&'static str>

fn get_detailed_message(&self) -> Option<&'static str>

fn get_documentation(&self) -> Option<&'static str>

Get the doc comment associated with a variant if it exists.

fn get_serializations(&self) -> &'static [&'static str]

impl From<&str> for SignificanceLevel

fn from(s: &str) -> SignificanceLevel

Converts to this type from the input type.

impl Hash for SignificanceLevel

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

where __H: Hasher,

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 SignificanceLevel

type Iterator = SignificanceLevelIter

fn iter() -> SignificanceLevelIter

impl Ord for SignificanceLevel

fn cmp(&self, other: &SignificanceLevel) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for SignificanceLevel

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

fn partial_cmp(&self, other: &SignificanceLevel) -> 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 SignificanceLevel

impl Eq for SignificanceLevel

impl StructuralPartialEq for SignificanceLevel