Enum sameold::EventCode

#[non_exhaustive]
#[repr(u8)]
pub enum EventCode {
    EmergencyActionNotification,
    NationalInformationCenter,
    NationalPeriodicTest,
    RequiredMonthlyTest,
    RequiredWeeklyTest,
    AdministrativeMessage,
    AvalancheWatch,
    AvalancheWarning,
    BlizzardWarning,
    BlueAlert,
    ChildAbductionEmergency,
    CivilDangerWarning,
    CivilEmergencyMessage,
    CoastalFloodWarning,
    CoastalFloodWatch,
    DustStormWarning,
    EarthquakeWarning,
    EvacuationImmediate,
    ExtremeWindWarning,
    FireWarning,
    FlashFloodWarning,
    FlashFloodWatch,
    FlashFloodStatement,
    FloodWarning,
    FloodWatch,
    FloodStatement,
    HazardousMaterialsWarning,
    HighWindWarning,
    HighWindWatch,
    HurricaneWarning,
    HurricaneWatch,
    HurricaneStatement,
    LawEnforcementWarning,
    LocalAreaEmergency,
    NetworkMessageNotification,
    TelephoneOutageEmergency,
    NuclearPowerPlantWarning,
    PracticeDemoWarning,
    RadiologicalHazardWarning,
    SevereThunderstormWarning,
    SevereThunderstormWatch,
    SevereWeatherStatement,
    ShelterInPlaceWarning,
    SpecialMarineWarning,
    SpecialWeatherStatement,
    StormSurgeWatch,
    StormSurgeWarning,
    TornadoWarning,
    TornadoWatch,
    TropicalStormWarning,
    TropicalStormWatch,
    TsunamiWarning,
    TsunamiWatch,
    VolcanoWarning,
    WinterStormWarning,
    WinterStormWatch,
}

SAME message event code

Usually constructed via MessageHeader::event(). Event codes were obtained from https://docs.fcc.gov/public/attachments/FCC-16-80A1.pdf.

Converting to string via .as_ref() will yield the SAME event code string. You can also obtain a human-readable message

use sameold::EventCode;

assert_eq!("RWT", (EventCode::RequiredWeeklyTest).as_ref());
assert_eq!("Required Weekly Test", (EventCode::RequiredWeeklyTest).as_display_str());
assert_eq!(
    "Required Weekly Test",
    format!("{}", EventCode::RequiredWeeklyTest)
);

All events are mapped to a significance level. This may be useful when deciding how to handle the event.

let lvl = (EventCode::RequiredWeeklyTest).to_significance_level();
assert_eq!(lvl, SignificanceLevel::Test);

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.

EmergencyActionNotification

Emergency Action Notification (begins national activation)

NationalInformationCenter

National Information Center (part of national activation)

NationalPeriodicTest

National Periodic Test

RequiredMonthlyTest

Required Monthly Test

RequiredWeeklyTest

Required Weekly Test

AdministrativeMessage

Administrative Message (state/local)

AvalancheWatch

Avalanche Watch

AvalancheWarning

Avalanche Warning

BlizzardWarning

Blizzard Warning

BlueAlert

Blue Alert (state/local)

ChildAbductionEmergency

Child Abduction Emergency (state/local)

CivilDangerWarning

Civil Danger Warning (state/local)

CivilEmergencyMessage

Civil Emergency Message (state/local)

CoastalFloodWarning

Coastal Flood Warning

CoastalFloodWatch

Coastal Flood Warning

DustStormWarning

Dust Storm Warning

EarthquakeWarning

Earthquake Warning

EvacuationImmediate

Evacuation Immediate

ExtremeWindWarning

Extreme Wind Warning

FireWarning

Fire Warning

FlashFloodWarning

Flash Flood Warning

FlashFloodWatch

Flash Flood Watch

FlashFloodStatement

Flash Flood Statement

FloodWarning

Flood Warning

FloodWatch

Flood Watch

FloodStatement

Flood Statement

HazardousMaterialsWarning

Hazardous Materials Warning

HighWindWarning

High Wind Warning

HighWindWatch

High Wind Watch

HurricaneWarning

Hurricane Warning

HurricaneWatch

Hurricane Watch

HurricaneStatement

Hurricane Statement

LawEnforcementWarning

Law Enforcement Warning

LocalAreaEmergency

Local Area Emergency

NetworkMessageNotification

Network Message Notification

TelephoneOutageEmergency

911 Telephone Outage Emergency

NuclearPowerPlantWarning

Nuclear Power Plant Warning

PracticeDemoWarning

Practice/Demo Warning

RadiologicalHazardWarning

Radiological Hazard Warning

SevereThunderstormWarning

Severe Thunderstorm Warning

SevereThunderstormWatch

Severe Thunderstorm Watch

SevereWeatherStatement

Severe Weather Statement

ShelterInPlaceWarning

Shelter In Place Warning

SpecialMarineWarning

Special Marine Warning

SpecialWeatherStatement

Special Weather Statement

StormSurgeWatch

Storm Surge Watch

StormSurgeWarning

Storm Surge Warning

TornadoWarning

Tornado Warning

TornadoWatch

Tornado Watch

TropicalStormWarning

Tropical Storm Warning

TropicalStormWatch

Tropical Storm Watch

TsunamiWarning

Tsunami Warning

TsunamiWatch

Tsunami Watch

VolcanoWarning

Volcano Warning

WinterStormWarning

Winter Storm Warning

WinterStormWatch

Winter Storm Warning

Implementations

impl EventCode

pub fn to_significance_level(&self) -> SignificanceLevel

Obtain event’s significance level

The significance level ranges from “Test” (i.e., “this is only a test”) to “Warning.” Each event code has a significance level associated with it. The SignificanceLevel is useful for determining whether an event merits a “noisy” and/or “immediate” alert for the message.

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

Human-readable string representation

Converts to a human-readable string, like “Required Monthly Test.”

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

SAME string representation

Returns the three-character SAME code for this EventCode.

Trait Implementations

impl AsRef<str> for EventCode

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

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

impl Clone for EventCode

fn clone(&self) -> EventCode

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for EventCode

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

Formats the value using the given formatter.

impl Display for EventCode

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

Formats the value using the given formatter.

impl EnumMessage for EventCode

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

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

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

impl EnumProperty for EventCode

fn get_str(&self, prop: &str) -> Option<&'static str>

fn get_int(&self, _prop: &str) -> Option<usize>

fn get_bool(&self, _prop: &str) -> Option<bool>

impl<'_derivative_strum> From<&'_derivative_strum EventCode> for &'static str

fn from(x: &'_derivative_strum EventCode) -> &'static str

Converts to this type from the input type.

impl From<&EventCode> for SignificanceLevel

fn from(evt: &EventCode) -> SignificanceLevel

Convert to significance level

impl From<EventCode> for &'static str

fn from(x: EventCode) -> &'static str

Converts to this type from the input type.

impl FromStr for EventCode

type Err = ParseError

The associated error which can be returned from parsing.

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

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

impl Hash for EventCode

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 EventCode

type Iterator = EventCodeIter

fn iter() -> EventCodeIter

impl PartialEq<EventCode> for EventCode

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl TryFrom<&str> for EventCode

fn try_from(inp: &str) -> Result<Self, Self::Error>

Convert from three-character SAME event code

Converts an event code like “SVR” into its enumerated type (EventCode::SevereThunderstormWarning).

If the code is unrecognized, an error is returned. An error here does NOT mean that the message is invalid or should be discarded. Instead, if the error is WithSignificance, then you should treat it as a valid (but unknown) message at the given significance level. This will help your application react correctly if new codes are added in the future.

type Error = UnrecognizedEventCode

The type returned in the event of a conversion error.

impl Copy for EventCode

impl Eq for EventCode

impl StructuralEq for EventCode

impl StructuralPartialEq for EventCode