Struct aws_sdk_cloudsearch::model::DomainStatus

#[non_exhaustive]
pub struct DomainStatus { /* private fields */ }

The current status of the search domain.

Implementations

impl DomainStatus

pub fn domain_id(&self) -> Option<&str>

An internally generated unique identifier for a domain.

pub fn domain_name(&self) -> Option<&str>

A string that represents the name of a domain. Domain names are unique across the domains owned by an account within an AWS region. Domain names start with a letter or number and can contain the following characters: a-z (lowercase), 0-9, and - (hyphen).

pub fn arn(&self) -> Option<&str>

The Amazon Resource Name (ARN) of the search domain. See Identifiers for IAM Entities in Using AWS Identity and Access Management for more information.

pub fn created(&self) -> Option<bool>

True if the search domain is created. It can take several minutes to initialize a domain when CreateDomain is called. Newly created search domains are returned from DescribeDomains with a false value for Created until domain creation is complete.

pub fn deleted(&self) -> Option<bool>

True if the search domain has been deleted. The system must clean up resources dedicated to the search domain when DeleteDomain is called. Newly deleted search domains are returned from DescribeDomains with a true value for IsDeleted for several minutes until resource cleanup is complete.

pub fn doc_service(&self) -> Option<&ServiceEndpoint>

The service endpoint for updating documents in a search domain.

pub fn search_service(&self) -> Option<&ServiceEndpoint>

The service endpoint for requesting search results from a search domain.

pub fn requires_index_documents(&self) -> Option<bool>

True if IndexDocuments needs to be called to activate the current domain configuration.

pub fn processing(&self) -> Option<bool>

True if processing is being done to activate the current domain configuration.

pub fn search_instance_type(&self) -> Option<&str>

The instance type that is being used to process search requests.

pub fn search_partition_count(&self) -> i32

The number of partitions across which the search index is spread.

pub fn search_instance_count(&self) -> i32

The number of search instances that are available to process search requests.

pub fn limits(&self) -> Option<&Limits>

impl DomainStatus

pub fn builder() -> Builder

Creates a new builder-style object to manufacture DomainStatus.

Examples found in repository

src/xml_deser.rs (line 1704)

pub fn deser_structure_crate_model_domain_status(
    decoder: &mut aws_smithy_xml::decode::ScopedDecoder,
) -> Result<crate::model::DomainStatus, aws_smithy_xml::decode::XmlDecodeError> {
    #[allow(unused_mut)]
    let mut builder = crate::model::DomainStatus::builder();
    while let Some(mut tag) = decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("DomainId") /* DomainId com.amazonaws.cloudsearch#DomainStatus$DomainId */ =>  {
                let var_43 =
                    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_domain_id(var_43);
            }
            ,
            s if s.matches("DomainName") /* DomainName com.amazonaws.cloudsearch#DomainStatus$DomainName */ =>  {
                let var_44 =
                    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_domain_name(var_44);
            }
            ,
            s if s.matches("ARN") /* ARN com.amazonaws.cloudsearch#DomainStatus$ARN */ =>  {
                let var_45 =
                    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_arn(var_45);
            }
            ,
            s if s.matches("Created") /* Created com.amazonaws.cloudsearch#DomainStatus$Created */ =>  {
                let var_46 =
                    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.cloudsearch#Boolean`)"))
                        }
                        ?
                    )
                ;
                builder = builder.set_created(var_46);
            }
            ,
            s if s.matches("Deleted") /* Deleted com.amazonaws.cloudsearch#DomainStatus$Deleted */ =>  {
                let var_47 =
                    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.cloudsearch#Boolean`)"))
                        }
                        ?
                    )
                ;
                builder = builder.set_deleted(var_47);
            }
            ,
            s if s.matches("DocService") /* DocService com.amazonaws.cloudsearch#DomainStatus$DocService */ =>  {
                let var_48 =
                    Some(
                        crate::xml_deser::deser_structure_crate_model_service_endpoint(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_doc_service(var_48);
            }
            ,
            s if s.matches("SearchService") /* SearchService com.amazonaws.cloudsearch#DomainStatus$SearchService */ =>  {
                let var_49 =
                    Some(
                        crate::xml_deser::deser_structure_crate_model_service_endpoint(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_search_service(var_49);
            }
            ,
            s if s.matches("RequiresIndexDocuments") /* RequiresIndexDocuments com.amazonaws.cloudsearch#DomainStatus$RequiresIndexDocuments */ =>  {
                let var_50 =
                    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.cloudsearch#Boolean`)"))
                        }
                        ?
                    )
                ;
                builder = builder.set_requires_index_documents(var_50);
            }
            ,
            s if s.matches("Processing") /* Processing com.amazonaws.cloudsearch#DomainStatus$Processing */ =>  {
                let var_51 =
                    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.cloudsearch#Boolean`)"))
                        }
                        ?
                    )
                ;
                builder = builder.set_processing(var_51);
            }
            ,
            s if s.matches("SearchInstanceType") /* SearchInstanceType com.amazonaws.cloudsearch#DomainStatus$SearchInstanceType */ =>  {
                let var_52 =
                    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_search_instance_type(var_52);
            }
            ,
            s if s.matches("SearchPartitionCount") /* SearchPartitionCount com.amazonaws.cloudsearch#DomainStatus$SearchPartitionCount */ =>  {
                let var_53 =
                    Some(
                         {
                            <i32 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 (integer: `com.amazonaws.cloudsearch#PartitionCount`)"))
                        }
                        ?
                    )
                ;
                builder = builder.set_search_partition_count(var_53);
            }
            ,
            s if s.matches("SearchInstanceCount") /* SearchInstanceCount com.amazonaws.cloudsearch#DomainStatus$SearchInstanceCount */ =>  {
                let var_54 =
                    Some(
                         {
                            <i32 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 (integer: `com.amazonaws.cloudsearch#InstanceCount`)"))
                        }
                        ?
                    )
                ;
                builder = builder.set_search_instance_count(var_54);
            }
            ,
            s if s.matches("Limits") /* Limits com.amazonaws.cloudsearch#DomainStatus$Limits */ =>  {
                let var_55 =
                    Some(
                        crate::xml_deser::deser_structure_crate_model_limits(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_limits(var_55);
            }
            ,
            _ => {}
        }
    }
    Ok(builder.build())
}

Trait Implementations

impl Clone for DomainStatus

fn clone(&self) -> DomainStatus

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for DomainStatus

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

Formats the value using the given formatter.

impl PartialEq<DomainStatus> for DomainStatus

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