Enum aws_sdk_securityhub::model::WorkflowState

#[non_exhaustive]
pub enum WorkflowState {
    Assigned,
    Deferred,
    InProgress,
    New,
    Resolved,
    Unknown(UnknownVariantValue),
}

👎Deprecated: This filter is deprecated. Instead, use SeverityLabel or FindingProviderFieldsSeverityLabel.

When writing a match expression against WorkflowState, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

Here is an example of how you can make a match expression forward-compatible:

# let workflowstate = unimplemented!();
match workflowstate {
    WorkflowState::Assigned => { /* ... */ },
    WorkflowState::Deferred => { /* ... */ },
    WorkflowState::InProgress => { /* ... */ },
    WorkflowState::New => { /* ... */ },
    WorkflowState::Resolved => { /* ... */ },
    other @ _ if other.as_str() == "NewFeature" => { /* handles a case for `NewFeature` */ },
    _ => { /* ... */ },
}

The above code demonstrates that when workflowstate represents NewFeature, the execution path will lead to the second last match arm, even though the enum does not contain a variant WorkflowState::NewFeature in the current version of SDK. The reason is that the variable other, created by the @ operator, is bound to WorkflowState::Unknown(UnknownVariantValue("NewFeature".to_owned())) and calling as_str on it yields "NewFeature". This match expression is forward-compatible when executed with a newer version of SDK where the variant WorkflowState::NewFeature is defined. Specifically, when workflowstate represents NewFeature, the execution path will hit the second last match arm as before by virtue of calling as_str on WorkflowState::NewFeature also yielding "NewFeature".

Explicitly matching on the Unknown variant should be avoided for two reasons:

• The inner data UnknownVariantValue is opaque, and no further information can be extracted.
• It might inadvertently shadow other intended match arms.

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.

Assigned

👎Deprecated: This filter is deprecated. Instead, use SeverityLabel or FindingProviderFieldsSeverityLabel.

Deferred

👎Deprecated: This filter is deprecated. Instead, use SeverityLabel or FindingProviderFieldsSeverityLabel.

InProgress

👎Deprecated: This filter is deprecated. Instead, use SeverityLabel or FindingProviderFieldsSeverityLabel.

New

👎Deprecated: This filter is deprecated. Instead, use SeverityLabel or FindingProviderFieldsSeverityLabel.

Resolved

👎Deprecated: This filter is deprecated. Instead, use SeverityLabel or FindingProviderFieldsSeverityLabel.

Unknown(UnknownVariantValue)

👎Deprecated: This filter is deprecated. Instead, use SeverityLabel or FindingProviderFieldsSeverityLabel.

Unknown contains new variants that have been added since this code was generated.

Implementations

impl WorkflowState

pub fn as_str(&self) -> &str

Returns the &str value of the enum member.

Examples found in repository

src/model.rs (line 9644)

    fn as_ref(&self) -> &str {
        self.as_str()
    }

src/json_ser.rs (line 872)

pub fn serialize_structure_crate_model_aws_security_finding(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsSecurityFinding,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_125) = &input.schema_version {
        object.key("SchemaVersion").string(var_125.as_str());
    }
    if let Some(var_126) = &input.id {
        object.key("Id").string(var_126.as_str());
    }
    if let Some(var_127) = &input.product_arn {
        object.key("ProductArn").string(var_127.as_str());
    }
    if let Some(var_128) = &input.product_name {
        object.key("ProductName").string(var_128.as_str());
    }
    if let Some(var_129) = &input.company_name {
        object.key("CompanyName").string(var_129.as_str());
    }
    if let Some(var_130) = &input.region {
        object.key("Region").string(var_130.as_str());
    }
    if let Some(var_131) = &input.generator_id {
        object.key("GeneratorId").string(var_131.as_str());
    }
    if let Some(var_132) = &input.aws_account_id {
        object.key("AwsAccountId").string(var_132.as_str());
    }
    if let Some(var_133) = &input.types {
        let mut array_134 = object.key("Types").start_array();
        for item_135 in var_133 {
            {
                array_134.value().string(item_135.as_str());
            }
        }
        array_134.finish();
    }
    if let Some(var_136) = &input.first_observed_at {
        object.key("FirstObservedAt").string(var_136.as_str());
    }
    if let Some(var_137) = &input.last_observed_at {
        object.key("LastObservedAt").string(var_137.as_str());
    }
    if let Some(var_138) = &input.created_at {
        object.key("CreatedAt").string(var_138.as_str());
    }
    if let Some(var_139) = &input.updated_at {
        object.key("UpdatedAt").string(var_139.as_str());
    }
    if let Some(var_140) = &input.severity {
        #[allow(unused_mut)]
        let mut object_141 = object.key("Severity").start_object();
        crate::json_ser::serialize_structure_crate_model_severity(&mut object_141, var_140)?;
        object_141.finish();
    }
    if input.confidence != 0 {
        object.key("Confidence").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.confidence).into()),
        );
    }
    if input.criticality != 0 {
        object.key("Criticality").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.criticality).into()),
        );
    }
    if let Some(var_142) = &input.title {
        object.key("Title").string(var_142.as_str());
    }
    if let Some(var_143) = &input.description {
        object.key("Description").string(var_143.as_str());
    }
    if let Some(var_144) = &input.remediation {
        #[allow(unused_mut)]
        let mut object_145 = object.key("Remediation").start_object();
        crate::json_ser::serialize_structure_crate_model_remediation(&mut object_145, var_144)?;
        object_145.finish();
    }
    if let Some(var_146) = &input.source_url {
        object.key("SourceUrl").string(var_146.as_str());
    }
    if let Some(var_147) = &input.product_fields {
        #[allow(unused_mut)]
        let mut object_148 = object.key("ProductFields").start_object();
        for (key_149, value_150) in var_147 {
            {
                object_148.key(key_149.as_str()).string(value_150.as_str());
            }
        }
        object_148.finish();
    }
    if let Some(var_151) = &input.user_defined_fields {
        #[allow(unused_mut)]
        let mut object_152 = object.key("UserDefinedFields").start_object();
        for (key_153, value_154) in var_151 {
            {
                object_152.key(key_153.as_str()).string(value_154.as_str());
            }
        }
        object_152.finish();
    }
    if let Some(var_155) = &input.malware {
        let mut array_156 = object.key("Malware").start_array();
        for item_157 in var_155 {
            {
                #[allow(unused_mut)]
                let mut object_158 = array_156.value().start_object();
                crate::json_ser::serialize_structure_crate_model_malware(
                    &mut object_158,
                    item_157,
                )?;
                object_158.finish();
            }
        }
        array_156.finish();
    }
    if let Some(var_159) = &input.network {
        #[allow(unused_mut)]
        let mut object_160 = object.key("Network").start_object();
        crate::json_ser::serialize_structure_crate_model_network(&mut object_160, var_159)?;
        object_160.finish();
    }
    if let Some(var_161) = &input.network_path {
        let mut array_162 = object.key("NetworkPath").start_array();
        for item_163 in var_161 {
            {
                #[allow(unused_mut)]
                let mut object_164 = array_162.value().start_object();
                crate::json_ser::serialize_structure_crate_model_network_path_component(
                    &mut object_164,
                    item_163,
                )?;
                object_164.finish();
            }
        }
        array_162.finish();
    }
    if let Some(var_165) = &input.process {
        #[allow(unused_mut)]
        let mut object_166 = object.key("Process").start_object();
        crate::json_ser::serialize_structure_crate_model_process_details(&mut object_166, var_165)?;
        object_166.finish();
    }
    if let Some(var_167) = &input.threats {
        let mut array_168 = object.key("Threats").start_array();
        for item_169 in var_167 {
            {
                #[allow(unused_mut)]
                let mut object_170 = array_168.value().start_object();
                crate::json_ser::serialize_structure_crate_model_threat(&mut object_170, item_169)?;
                object_170.finish();
            }
        }
        array_168.finish();
    }
    if let Some(var_171) = &input.threat_intel_indicators {
        let mut array_172 = object.key("ThreatIntelIndicators").start_array();
        for item_173 in var_171 {
            {
                #[allow(unused_mut)]
                let mut object_174 = array_172.value().start_object();
                crate::json_ser::serialize_structure_crate_model_threat_intel_indicator(
                    &mut object_174,
                    item_173,
                )?;
                object_174.finish();
            }
        }
        array_172.finish();
    }
    if let Some(var_175) = &input.resources {
        let mut array_176 = object.key("Resources").start_array();
        for item_177 in var_175 {
            {
                #[allow(unused_mut)]
                let mut object_178 = array_176.value().start_object();
                crate::json_ser::serialize_structure_crate_model_resource(
                    &mut object_178,
                    item_177,
                )?;
                object_178.finish();
            }
        }
        array_176.finish();
    }
    if let Some(var_179) = &input.compliance {
        #[allow(unused_mut)]
        let mut object_180 = object.key("Compliance").start_object();
        crate::json_ser::serialize_structure_crate_model_compliance(&mut object_180, var_179)?;
        object_180.finish();
    }
    if let Some(var_181) = &input.verification_state {
        object.key("VerificationState").string(var_181.as_str());
    }
    if let Some(var_182) = &input.workflow_state {
        object.key("WorkflowState").string(var_182.as_str());
    }
    if let Some(var_183) = &input.workflow {
        #[allow(unused_mut)]
        let mut object_184 = object.key("Workflow").start_object();
        crate::json_ser::serialize_structure_crate_model_workflow(&mut object_184, var_183)?;
        object_184.finish();
    }
    if let Some(var_185) = &input.record_state {
        object.key("RecordState").string(var_185.as_str());
    }
    if let Some(var_186) = &input.related_findings {
        let mut array_187 = object.key("RelatedFindings").start_array();
        for item_188 in var_186 {
            {
                #[allow(unused_mut)]
                let mut object_189 = array_187.value().start_object();
                crate::json_ser::serialize_structure_crate_model_related_finding(
                    &mut object_189,
                    item_188,
                )?;
                object_189.finish();
            }
        }
        array_187.finish();
    }
    if let Some(var_190) = &input.note {
        #[allow(unused_mut)]
        let mut object_191 = object.key("Note").start_object();
        crate::json_ser::serialize_structure_crate_model_note(&mut object_191, var_190)?;
        object_191.finish();
    }
    if let Some(var_192) = &input.vulnerabilities {
        let mut array_193 = object.key("Vulnerabilities").start_array();
        for item_194 in var_192 {
            {
                #[allow(unused_mut)]
                let mut object_195 = array_193.value().start_object();
                crate::json_ser::serialize_structure_crate_model_vulnerability(
                    &mut object_195,
                    item_194,
                )?;
                object_195.finish();
            }
        }
        array_193.finish();
    }
    if let Some(var_196) = &input.patch_summary {
        #[allow(unused_mut)]
        let mut object_197 = object.key("PatchSummary").start_object();
        crate::json_ser::serialize_structure_crate_model_patch_summary(&mut object_197, var_196)?;
        object_197.finish();
    }
    if let Some(var_198) = &input.action {
        #[allow(unused_mut)]
        let mut object_199 = object.key("Action").start_object();
        crate::json_ser::serialize_structure_crate_model_action(&mut object_199, var_198)?;
        object_199.finish();
    }
    if let Some(var_200) = &input.finding_provider_fields {
        #[allow(unused_mut)]
        let mut object_201 = object.key("FindingProviderFields").start_object();
        crate::json_ser::serialize_structure_crate_model_finding_provider_fields(
            &mut object_201,
            var_200,
        )?;
        object_201.finish();
    }
    if input.sample {
        object.key("Sample").boolean(input.sample);
    }
    Ok(())
}

pub const fn values() -> &'static [&'static str]

Returns all the &str values of the enum members.

Trait Implementations

impl AsRef<str> for WorkflowState

fn as_ref(&self) -> &str

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

impl Clone for WorkflowState

fn clone(&self) -> WorkflowState

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for WorkflowState

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

Formats the value using the given formatter.

impl From<&str> for WorkflowState

fn from(s: &str) -> Self

Converts to this type from the input type.

impl FromStr for WorkflowState

type Err = Infallible

The associated error which can be returned from parsing.

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

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

impl Hash for WorkflowState

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 Ord for WorkflowState

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

This method returns an Ordering between self and other.

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

Compares and returns the maximum of two values.

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

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Selfwhere
    Self: Sized + PartialOrd<Self>,

Restrict a value to a certain interval.

impl PartialEq<WorkflowState> for WorkflowState

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

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

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

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

This method tests less than (for self and other) and is used by the < operator.

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

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

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

This method tests greater than (for self and other) and is used by the > operator.

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

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

impl Eq for WorkflowState

impl StructuralEq for WorkflowState

impl StructuralPartialEq for WorkflowState