Struct aws_sdk_elasticache::model::service_update::Builder

source ·

pub struct Builder { /* private fields */ }

Expand description

The estimated length of time the service update will take

Examples found in repository ?

src/xml_deser.rs (line 10073)

pub fn deser_structure_crate_model_service_update(
    decoder: &mut aws_smithy_xml::decode::ScopedDecoder,
) -> Result<crate::model::ServiceUpdate, aws_smithy_xml::decode::XmlDecodeError> {
    #[allow(unused_mut)]
    let mut builder = crate::model::ServiceUpdate::builder();
    while let Some(mut tag) = decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("ServiceUpdateName") /* ServiceUpdateName com.amazonaws.elasticache#ServiceUpdate$ServiceUpdateName */ =>  {
                let var_396 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_service_update_name(var_396);
            }
            ,
            s if s.matches("ServiceUpdateReleaseDate") /* ServiceUpdateReleaseDate com.amazonaws.elasticache#ServiceUpdate$ServiceUpdateReleaseDate */ =>  {
                let var_397 =
                    Some(
                        aws_smithy_types::DateTime::from_str(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            , aws_smithy_types::date_time::Format::DateTime
                        )
                        .map_err(|_|aws_smithy_xml::decode::XmlDecodeError::custom("expected (timestamp: `com.amazonaws.elasticache#TStamp`)"))
                        ?
                    )
                ;
                builder = builder.set_service_update_release_date(var_397);
            }
            ,
            s if s.matches("ServiceUpdateEndDate") /* ServiceUpdateEndDate com.amazonaws.elasticache#ServiceUpdate$ServiceUpdateEndDate */ =>  {
                let var_398 =
                    Some(
                        aws_smithy_types::DateTime::from_str(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            , aws_smithy_types::date_time::Format::DateTime
                        )
                        .map_err(|_|aws_smithy_xml::decode::XmlDecodeError::custom("expected (timestamp: `com.amazonaws.elasticache#TStamp`)"))
                        ?
                    )
                ;
                builder = builder.set_service_update_end_date(var_398);
            }
            ,
            s if s.matches("ServiceUpdateSeverity") /* ServiceUpdateSeverity com.amazonaws.elasticache#ServiceUpdate$ServiceUpdateSeverity */ =>  {
                let var_399 =
                    Some(
                        Result::<crate::model::ServiceUpdateSeverity, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            crate::model::ServiceUpdateSeverity::from(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                        )
                        ?
                    )
                ;
                builder = builder.set_service_update_severity(var_399);
            }
            ,
            s if s.matches("ServiceUpdateRecommendedApplyByDate") /* ServiceUpdateRecommendedApplyByDate com.amazonaws.elasticache#ServiceUpdate$ServiceUpdateRecommendedApplyByDate */ =>  {
                let var_400 =
                    Some(
                        aws_smithy_types::DateTime::from_str(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            , aws_smithy_types::date_time::Format::DateTime
                        )
                        .map_err(|_|aws_smithy_xml::decode::XmlDecodeError::custom("expected (timestamp: `com.amazonaws.elasticache#TStamp`)"))
                        ?
                    )
                ;
                builder = builder.set_service_update_recommended_apply_by_date(var_400);
            }
            ,
            s if s.matches("ServiceUpdateStatus") /* ServiceUpdateStatus com.amazonaws.elasticache#ServiceUpdate$ServiceUpdateStatus */ =>  {
                let var_401 =
                    Some(
                        Result::<crate::model::ServiceUpdateStatus, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            crate::model::ServiceUpdateStatus::from(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                        )
                        ?
                    )
                ;
                builder = builder.set_service_update_status(var_401);
            }
            ,
            s if s.matches("ServiceUpdateDescription") /* ServiceUpdateDescription com.amazonaws.elasticache#ServiceUpdate$ServiceUpdateDescription */ =>  {
                let var_402 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_service_update_description(var_402);
            }
            ,
            s if s.matches("ServiceUpdateType") /* ServiceUpdateType com.amazonaws.elasticache#ServiceUpdate$ServiceUpdateType */ =>  {
                let var_403 =
                    Some(
                        Result::<crate::model::ServiceUpdateType, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            crate::model::ServiceUpdateType::from(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                        )
                        ?
                    )
                ;
                builder = builder.set_service_update_type(var_403);
            }
            ,
            s if s.matches("Engine") /* Engine com.amazonaws.elasticache#ServiceUpdate$Engine */ =>  {
                let var_404 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_engine(var_404);
            }
            ,
            s if s.matches("EngineVersion") /* EngineVersion com.amazonaws.elasticache#ServiceUpdate$EngineVersion */ =>  {
                let var_405 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_engine_version(var_405);
            }
            ,
            s if s.matches("AutoUpdateAfterRecommendedApplyByDate") /* AutoUpdateAfterRecommendedApplyByDate com.amazonaws.elasticache#ServiceUpdate$AutoUpdateAfterRecommendedApplyByDate */ =>  {
                let var_406 =
                    Some(
                         {
                            <bool as aws_smithy_types::primitive::Parse>::parse_smithy_primitive(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                            .map_err(|_|aws_smithy_xml::decode::XmlDecodeError::custom("expected (boolean: `com.amazonaws.elasticache#BooleanOptional`)"))
                        }
                        ?
                    )
                ;
                builder = builder.set_auto_update_after_recommended_apply_by_date(var_406);
            }
            ,
            s if s.matches("EstimatedUpdateTime") /* EstimatedUpdateTime com.amazonaws.elasticache#ServiceUpdate$EstimatedUpdateTime */ =>  {
                let var_407 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_estimated_update_time(var_407);
            }
            ,
            _ => {}
        }
    }
    Ok(builder.build())
}

source

pub fn build(self) -> ServiceUpdate

Consumes the builder and constructs a ServiceUpdate.

Examples found in repository ?

src/xml_deser.rs (line 10079)

pub fn deser_structure_crate_model_service_update(
    decoder: &mut aws_smithy_xml::decode::ScopedDecoder,
) -> Result<crate::model::ServiceUpdate, aws_smithy_xml::decode::XmlDecodeError> {
    #[allow(unused_mut)]
    let mut builder = crate::model::ServiceUpdate::builder();
    while let Some(mut tag) = decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("ServiceUpdateName") /* ServiceUpdateName com.amazonaws.elasticache#ServiceUpdate$ServiceUpdateName */ =>  {
                let var_396 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_service_update_name(var_396);
            }
            ,
            s if s.matches("ServiceUpdateReleaseDate") /* ServiceUpdateReleaseDate com.amazonaws.elasticache#ServiceUpdate$ServiceUpdateReleaseDate */ =>  {
                let var_397 =
                    Some(
                        aws_smithy_types::DateTime::from_str(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            , aws_smithy_types::date_time::Format::DateTime
                        )
                        .map_err(|_|aws_smithy_xml::decode::XmlDecodeError::custom("expected (timestamp: `com.amazonaws.elasticache#TStamp`)"))
                        ?
                    )
                ;
                builder = builder.set_service_update_release_date(var_397);
            }
            ,
            s if s.matches("ServiceUpdateEndDate") /* ServiceUpdateEndDate com.amazonaws.elasticache#ServiceUpdate$ServiceUpdateEndDate */ =>  {
                let var_398 =
                    Some(
                        aws_smithy_types::DateTime::from_str(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            , aws_smithy_types::date_time::Format::DateTime
                        )
                        .map_err(|_|aws_smithy_xml::decode::XmlDecodeError::custom("expected (timestamp: `com.amazonaws.elasticache#TStamp`)"))
                        ?
                    )
                ;
                builder = builder.set_service_update_end_date(var_398);
            }
            ,
            s if s.matches("ServiceUpdateSeverity") /* ServiceUpdateSeverity com.amazonaws.elasticache#ServiceUpdate$ServiceUpdateSeverity */ =>  {
                let var_399 =
                    Some(
                        Result::<crate::model::ServiceUpdateSeverity, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            crate::model::ServiceUpdateSeverity::from(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                        )
                        ?
                    )
                ;
                builder = builder.set_service_update_severity(var_399);
            }
            ,
            s if s.matches("ServiceUpdateRecommendedApplyByDate") /* ServiceUpdateRecommendedApplyByDate com.amazonaws.elasticache#ServiceUpdate$ServiceUpdateRecommendedApplyByDate */ =>  {
                let var_400 =
                    Some(
                        aws_smithy_types::DateTime::from_str(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            , aws_smithy_types::date_time::Format::DateTime
                        )
                        .map_err(|_|aws_smithy_xml::decode::XmlDecodeError::custom("expected (timestamp: `com.amazonaws.elasticache#TStamp`)"))
                        ?
                    )
                ;
                builder = builder.set_service_update_recommended_apply_by_date(var_400);
            }
            ,
            s if s.matches("ServiceUpdateStatus") /* ServiceUpdateStatus com.amazonaws.elasticache#ServiceUpdate$ServiceUpdateStatus */ =>  {
                let var_401 =
                    Some(
                        Result::<crate::model::ServiceUpdateStatus, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            crate::model::ServiceUpdateStatus::from(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                        )
                        ?
                    )
                ;
                builder = builder.set_service_update_status(var_401);
            }
            ,
            s if s.matches("ServiceUpdateDescription") /* ServiceUpdateDescription com.amazonaws.elasticache#ServiceUpdate$ServiceUpdateDescription */ =>  {
                let var_402 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_service_update_description(var_402);
            }
            ,
            s if s.matches("ServiceUpdateType") /* ServiceUpdateType com.amazonaws.elasticache#ServiceUpdate$ServiceUpdateType */ =>  {
                let var_403 =
                    Some(
                        Result::<crate::model::ServiceUpdateType, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            crate::model::ServiceUpdateType::from(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                        )
                        ?
                    )
                ;
                builder = builder.set_service_update_type(var_403);
            }
            ,
            s if s.matches("Engine") /* Engine com.amazonaws.elasticache#ServiceUpdate$Engine */ =>  {
                let var_404 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_engine(var_404);
            }
            ,
            s if s.matches("EngineVersion") /* EngineVersion com.amazonaws.elasticache#ServiceUpdate$EngineVersion */ =>  {
                let var_405 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_engine_version(var_405);
            }
            ,
            s if s.matches("AutoUpdateAfterRecommendedApplyByDate") /* AutoUpdateAfterRecommendedApplyByDate com.amazonaws.elasticache#ServiceUpdate$AutoUpdateAfterRecommendedApplyByDate */ =>  {
                let var_406 =
                    Some(
                         {
                            <bool as aws_smithy_types::primitive::Parse>::parse_smithy_primitive(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                            .map_err(|_|aws_smithy_xml::decode::XmlDecodeError::custom("expected (boolean: `com.amazonaws.elasticache#BooleanOptional`)"))
                        }
                        ?
                    )
                ;
                builder = builder.set_auto_update_after_recommended_apply_by_date(var_406);
            }
            ,
            s if s.matches("EstimatedUpdateTime") /* EstimatedUpdateTime com.amazonaws.elasticache#ServiceUpdate$EstimatedUpdateTime */ =>  {
                let var_407 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_estimated_update_time(var_407);
            }
            ,
            _ => {}
        }
    }
    Ok(builder.build())
}

Trait Implementations§

source §

impl Clone for Builder

source §

fn clone(&self) -> Builder

Returns a copy of the value. Read more

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

source §

impl StructuralPartialEq for Builder

impl<T> ToOwned for Twhere
T: Clone,

§

type Owned = T

impl<T> WithSubscriber for T

source §

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where
S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a WithDispatch wrapper. Read more

source §

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a WithDispatch wrapper. Read more

Struct aws_sdk_elasticache::model::service_update::Builder

Implementations§

impl Builder

pub fn service_update_name(self, input: impl Into<String>) -> Self

pub fn set_service_update_name(self, input: Option<String>) -> Self

pub fn service_update_release_date(self, input: DateTime) -> Self

pub fn set_service_update_release_date(self, input: Option<DateTime>) -> Self

pub fn service_update_end_date(self, input: DateTime) -> Self

pub fn set_service_update_end_date(self, input: Option<DateTime>) -> Self

pub fn service_update_severity(self, input: ServiceUpdateSeverity) -> Self

pub fn set_service_update_severity( self, input: Option<ServiceUpdateSeverity>) -> Self

pub fn service_update_recommended_apply_by_date(self, input: DateTime) -> Self

pub fn set_service_update_recommended_apply_by_date( self, input: Option<DateTime>) -> Self

pub fn service_update_status(self, input: ServiceUpdateStatus) -> Self

pub fn set_service_update_status( self, input: Option<ServiceUpdateStatus>) -> Self

pub fn service_update_description(self, input: impl Into<String>) -> Self

pub fn set_service_update_description(self, input: Option<String>) -> Self

pub fn service_update_type(self, input: ServiceUpdateType) -> Self

pub fn set_service_update_type(self, input: Option<ServiceUpdateType>) -> Self

pub fn engine(self, input: impl Into<String>) -> Self

pub fn set_engine(self, input: Option<String>) -> Self

pub fn engine_version(self, input: impl Into<String>) -> Self

pub fn set_engine_version(self, input: Option<String>) -> Self

pub fn auto_update_after_recommended_apply_by_date(self, input: bool) -> Self

pub fn set_auto_update_after_recommended_apply_by_date( self, input: Option<bool>) -> Self

pub fn estimated_update_time(self, input: impl Into<String>) -> Self

pub fn set_estimated_update_time(self, input: Option<String>) -> Self

pub fn build(self) -> ServiceUpdate

Trait Implementations§

impl Clone for Builder

fn clone(&self) -> Builder

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

impl Debug for Builder

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

impl Default for Builder

fn default() -> Builder

impl PartialEq<Builder> for Builder

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

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

impl StructuralPartialEq for Builder

Auto Trait Implementations§

impl RefUnwindSafe for Builder

impl Send for Builder

impl Sync for Builder

impl Unpin for Builder

impl UnwindSafe for Builder

Blanket Implementations§

impl<T> Any for Twhere T: 'static + ?Sized,

fn type_id(&self) -> TypeId

impl<T> Borrow<T> for Twhere T: ?Sized,

fn borrow(&self) -> &T

impl<T> BorrowMut<T> for Twhere T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

impl<T> From<T> for T

fn from(t: T) -> T

impl<T> Instrument for T

fn instrument(self, span: Span) -> Instrumented<Self>

fn in_current_span(self) -> Instrumented<Self>

impl<T, U> Into<U> for Twhere U: From<T>,

fn into(self) -> U

impl<T> Same<T> for T

type Output = T

impl<T> ToOwned for Twhere T: Clone,

type Owned = T

fn to_owned(&self) -> T

fn clone_into(&self, target: &mut T)

impl<T, U> TryFrom<U> for Twhere U: Into<T>,

type Error = Infallible

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

impl<T, U> TryInto<U> for Twhere U: TryFrom<T>,

type Error = <U as TryFrom<T>>::Error

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

impl<T> WithSubscriber for T

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where S: Into<Dispatch>,

fn with_current_subscriber(self) -> WithDispatch<Self>

pub fn set_service_update_severity(
self,
input: Option<ServiceUpdateSeverity>
) -> Self

pub fn set_service_update_recommended_apply_by_date(
self,
input: Option<DateTime>
) -> Self

pub fn set_service_update_status(
self,
input: Option<ServiceUpdateStatus>
) -> Self

pub fn set_auto_update_after_recommended_apply_by_date(
self,
input: Option<bool>
) -> Self

impl<T> Any for Twhere
T: 'static + ?Sized,

impl<T> Borrow<T> for Twhere
T: ?Sized,

impl<T> BorrowMut<T> for Twhere
T: ?Sized,

impl<T, U> Into<U> for Twhere
U: From<T>,

impl<T> ToOwned for Twhere
T: Clone,

impl<T, U> TryFrom<U> for Twhere
U: Into<T>,

impl<T, U> TryInto<U> for Twhere
U: TryFrom<T>,

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where
S: Into<Dispatch>,