use std::error::Error;
use std::fmt;
use async_trait::async_trait;
use rusoto_core::credential::ProvideAwsCredentials;
use rusoto_core::region;
use rusoto_core::request::{BufferedHttpResponse, DispatchSignedRequest};
use rusoto_core::{Client, RusotoError};
use rusoto_core::param::{Params, ServiceParams};
use rusoto_core::proto::xml::error::*;
use rusoto_core::proto::xml::util::{
self as xml_util, deserialize_elements, find_start_element, skip_tree,
};
use rusoto_core::proto::xml::util::{Next, Peek, XmlParseError, XmlResponse};
use rusoto_core::request::HttpResponse;
use rusoto_core::signature::SignedRequest;
#[cfg(feature = "deserialize_structs")]
use serde::Deserialize;
#[cfg(feature = "serialize_structs")]
use serde::Serialize;
use serde_urlencoded;
use std::str::FromStr;
use xml::EventReader;
impl CloudSearchClient {
fn new_params(&self, operation_name: &str) -> Params {
let mut params = Params::new();
params.put("Action", operation_name);
params.put("Version", "2013-01-01");
params
}
async fn sign_and_dispatch<E>(
&self,
request: SignedRequest,
from_response: fn(BufferedHttpResponse) -> RusotoError<E>,
) -> Result<HttpResponse, RusotoError<E>> {
let mut response = self.client.sign_and_dispatch(request).await?;
if !response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
return Err(from_response(response));
}
Ok(response)
}
}
#[allow(dead_code)]
struct APIVersionDeserializer;
impl APIVersionDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct ARNDeserializer;
impl ARNDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct AccessPoliciesStatus {
pub options: String,
pub status: OptionStatus,
}
#[allow(dead_code)]
struct AccessPoliciesStatusDeserializer;
impl AccessPoliciesStatusDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<AccessPoliciesStatus, XmlParseError> {
deserialize_elements::<_, AccessPoliciesStatus, _>(tag_name, stack, |name, stack, obj| {
match name {
"Options" => {
obj.options = PolicyDocumentDeserializer::deserialize("Options", stack)?;
}
"Status" => {
obj.status = OptionStatusDeserializer::deserialize("Status", stack)?;
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[allow(dead_code)]
struct AlgorithmicStemmingDeserializer;
impl AlgorithmicStemmingDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AnalysisOptions {
pub algorithmic_stemming: Option<String>,
pub japanese_tokenization_dictionary: Option<String>,
pub stemming_dictionary: Option<String>,
pub stopwords: Option<String>,
pub synonyms: Option<String>,
}
#[allow(dead_code)]
struct AnalysisOptionsDeserializer;
impl AnalysisOptionsDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<AnalysisOptions, XmlParseError> {
deserialize_elements::<_, AnalysisOptions, _>(tag_name, stack, |name, stack, obj| {
match name {
"AlgorithmicStemming" => {
obj.algorithmic_stemming = Some(AlgorithmicStemmingDeserializer::deserialize(
"AlgorithmicStemming",
stack,
)?);
}
"JapaneseTokenizationDictionary" => {
obj.japanese_tokenization_dictionary = Some(StringDeserializer::deserialize(
"JapaneseTokenizationDictionary",
stack,
)?);
}
"StemmingDictionary" => {
obj.stemming_dictionary = Some(StringDeserializer::deserialize(
"StemmingDictionary",
stack,
)?);
}
"Stopwords" => {
obj.stopwords = Some(StringDeserializer::deserialize("Stopwords", stack)?);
}
"Synonyms" => {
obj.synonyms = Some(StringDeserializer::deserialize("Synonyms", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct AnalysisOptionsSerializer;
impl AnalysisOptionsSerializer {
fn serialize(params: &mut Params, name: &str, obj: &AnalysisOptions) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.algorithmic_stemming {
params.put(
&format!("{}{}", prefix, "AlgorithmicStemming"),
&field_value,
);
}
if let Some(ref field_value) = obj.japanese_tokenization_dictionary {
params.put(
&format!("{}{}", prefix, "JapaneseTokenizationDictionary"),
&field_value,
);
}
if let Some(ref field_value) = obj.stemming_dictionary {
params.put(&format!("{}{}", prefix, "StemmingDictionary"), &field_value);
}
if let Some(ref field_value) = obj.stopwords {
params.put(&format!("{}{}", prefix, "Stopwords"), &field_value);
}
if let Some(ref field_value) = obj.synonyms {
params.put(&format!("{}{}", prefix, "Synonyms"), &field_value);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AnalysisScheme {
pub analysis_options: Option<AnalysisOptions>,
pub analysis_scheme_language: String,
pub analysis_scheme_name: String,
}
#[allow(dead_code)]
struct AnalysisSchemeDeserializer;
impl AnalysisSchemeDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<AnalysisScheme, XmlParseError> {
deserialize_elements::<_, AnalysisScheme, _>(tag_name, stack, |name, stack, obj| {
match name {
"AnalysisOptions" => {
obj.analysis_options = Some(AnalysisOptionsDeserializer::deserialize(
"AnalysisOptions",
stack,
)?);
}
"AnalysisSchemeLanguage" => {
obj.analysis_scheme_language = AnalysisSchemeLanguageDeserializer::deserialize(
"AnalysisSchemeLanguage",
stack,
)?;
}
"AnalysisSchemeName" => {
obj.analysis_scheme_name =
StandardNameDeserializer::deserialize("AnalysisSchemeName", stack)?;
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct AnalysisSchemeSerializer;
impl AnalysisSchemeSerializer {
fn serialize(params: &mut Params, name: &str, obj: &AnalysisScheme) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.analysis_options {
AnalysisOptionsSerializer::serialize(
params,
&format!("{}{}", prefix, "AnalysisOptions"),
field_value,
);
}
params.put(
&format!("{}{}", prefix, "AnalysisSchemeLanguage"),
&obj.analysis_scheme_language,
);
params.put(
&format!("{}{}", prefix, "AnalysisSchemeName"),
&obj.analysis_scheme_name,
);
}
}
#[allow(dead_code)]
struct AnalysisSchemeLanguageDeserializer;
impl AnalysisSchemeLanguageDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct AnalysisSchemeStatus {
pub options: AnalysisScheme,
pub status: OptionStatus,
}
#[allow(dead_code)]
struct AnalysisSchemeStatusDeserializer;
impl AnalysisSchemeStatusDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<AnalysisSchemeStatus, XmlParseError> {
deserialize_elements::<_, AnalysisSchemeStatus, _>(tag_name, stack, |name, stack, obj| {
match name {
"Options" => {
obj.options = AnalysisSchemeDeserializer::deserialize("Options", stack)?;
}
"Status" => {
obj.status = OptionStatusDeserializer::deserialize("Status", stack)?;
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[allow(dead_code)]
struct AnalysisSchemeStatusListDeserializer;
impl AnalysisSchemeStatusListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<AnalysisSchemeStatus>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "member" {
obj.push(AnalysisSchemeStatusDeserializer::deserialize(
"member", stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct AvailabilityOptionsStatus {
pub options: bool,
pub status: OptionStatus,
}
#[allow(dead_code)]
struct AvailabilityOptionsStatusDeserializer;
impl AvailabilityOptionsStatusDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<AvailabilityOptionsStatus, XmlParseError> {
deserialize_elements::<_, AvailabilityOptionsStatus, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"Options" => {
obj.options = MultiAZDeserializer::deserialize("Options", stack)?;
}
"Status" => {
obj.status = OptionStatusDeserializer::deserialize("Status", stack)?;
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[allow(dead_code)]
struct BooleanDeserializer;
impl BooleanDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<bool, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, |s| Ok(bool::from_str(&s).unwrap()))
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct BuildSuggestersRequest {
pub domain_name: String,
}
struct BuildSuggestersRequestSerializer;
impl BuildSuggestersRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &BuildSuggestersRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(&format!("{}{}", prefix, "DomainName"), &obj.domain_name);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct BuildSuggestersResponse {
pub field_names: Option<Vec<String>>,
}
#[allow(dead_code)]
struct BuildSuggestersResponseDeserializer;
impl BuildSuggestersResponseDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<BuildSuggestersResponse, XmlParseError> {
deserialize_elements::<_, BuildSuggestersResponse, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"FieldNames" => {
obj.field_names
.get_or_insert(vec![])
.extend(FieldNameListDeserializer::deserialize("FieldNames", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateDomainRequest {
pub domain_name: String,
}
struct CreateDomainRequestSerializer;
impl CreateDomainRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CreateDomainRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(&format!("{}{}", prefix, "DomainName"), &obj.domain_name);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct CreateDomainResponse {
pub domain_status: Option<DomainStatus>,
}
#[allow(dead_code)]
struct CreateDomainResponseDeserializer;
impl CreateDomainResponseDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CreateDomainResponse, XmlParseError> {
deserialize_elements::<_, CreateDomainResponse, _>(tag_name, stack, |name, stack, obj| {
match name {
"DomainStatus" => {
obj.domain_status = Some(DomainStatusDeserializer::deserialize(
"DomainStatus",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DateArrayOptions {
pub default_value: Option<String>,
pub facet_enabled: Option<bool>,
pub return_enabled: Option<bool>,
pub search_enabled: Option<bool>,
pub source_fields: Option<String>,
}
#[allow(dead_code)]
struct DateArrayOptionsDeserializer;
impl DateArrayOptionsDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DateArrayOptions, XmlParseError> {
deserialize_elements::<_, DateArrayOptions, _>(tag_name, stack, |name, stack, obj| {
match name {
"DefaultValue" => {
obj.default_value =
Some(FieldValueDeserializer::deserialize("DefaultValue", stack)?);
}
"FacetEnabled" => {
obj.facet_enabled =
Some(BooleanDeserializer::deserialize("FacetEnabled", stack)?);
}
"ReturnEnabled" => {
obj.return_enabled =
Some(BooleanDeserializer::deserialize("ReturnEnabled", stack)?);
}
"SearchEnabled" => {
obj.search_enabled =
Some(BooleanDeserializer::deserialize("SearchEnabled", stack)?);
}
"SourceFields" => {
obj.source_fields = Some(FieldNameCommaListDeserializer::deserialize(
"SourceFields",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct DateArrayOptionsSerializer;
impl DateArrayOptionsSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DateArrayOptions) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.default_value {
params.put(&format!("{}{}", prefix, "DefaultValue"), &field_value);
}
if let Some(ref field_value) = obj.facet_enabled {
params.put(&format!("{}{}", prefix, "FacetEnabled"), &field_value);
}
if let Some(ref field_value) = obj.return_enabled {
params.put(&format!("{}{}", prefix, "ReturnEnabled"), &field_value);
}
if let Some(ref field_value) = obj.search_enabled {
params.put(&format!("{}{}", prefix, "SearchEnabled"), &field_value);
}
if let Some(ref field_value) = obj.source_fields {
params.put(&format!("{}{}", prefix, "SourceFields"), &field_value);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DateOptions {
pub default_value: Option<String>,
pub facet_enabled: Option<bool>,
pub return_enabled: Option<bool>,
pub search_enabled: Option<bool>,
pub sort_enabled: Option<bool>,
pub source_field: Option<String>,
}
#[allow(dead_code)]
struct DateOptionsDeserializer;
impl DateOptionsDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DateOptions, XmlParseError> {
deserialize_elements::<_, DateOptions, _>(tag_name, stack, |name, stack, obj| {
match name {
"DefaultValue" => {
obj.default_value =
Some(FieldValueDeserializer::deserialize("DefaultValue", stack)?);
}
"FacetEnabled" => {
obj.facet_enabled =
Some(BooleanDeserializer::deserialize("FacetEnabled", stack)?);
}
"ReturnEnabled" => {
obj.return_enabled =
Some(BooleanDeserializer::deserialize("ReturnEnabled", stack)?);
}
"SearchEnabled" => {
obj.search_enabled =
Some(BooleanDeserializer::deserialize("SearchEnabled", stack)?);
}
"SortEnabled" => {
obj.sort_enabled =
Some(BooleanDeserializer::deserialize("SortEnabled", stack)?);
}
"SourceField" => {
obj.source_field =
Some(FieldNameDeserializer::deserialize("SourceField", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct DateOptionsSerializer;
impl DateOptionsSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DateOptions) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.default_value {
params.put(&format!("{}{}", prefix, "DefaultValue"), &field_value);
}
if let Some(ref field_value) = obj.facet_enabled {
params.put(&format!("{}{}", prefix, "FacetEnabled"), &field_value);
}
if let Some(ref field_value) = obj.return_enabled {
params.put(&format!("{}{}", prefix, "ReturnEnabled"), &field_value);
}
if let Some(ref field_value) = obj.search_enabled {
params.put(&format!("{}{}", prefix, "SearchEnabled"), &field_value);
}
if let Some(ref field_value) = obj.sort_enabled {
params.put(&format!("{}{}", prefix, "SortEnabled"), &field_value);
}
if let Some(ref field_value) = obj.source_field {
params.put(&format!("{}{}", prefix, "SourceField"), &field_value);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DefineAnalysisSchemeRequest {
pub analysis_scheme: AnalysisScheme,
pub domain_name: String,
}
struct DefineAnalysisSchemeRequestSerializer;
impl DefineAnalysisSchemeRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DefineAnalysisSchemeRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
AnalysisSchemeSerializer::serialize(
params,
&format!("{}{}", prefix, "AnalysisScheme"),
&obj.analysis_scheme,
);
params.put(&format!("{}{}", prefix, "DomainName"), &obj.domain_name);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct DefineAnalysisSchemeResponse {
pub analysis_scheme: AnalysisSchemeStatus,
}
#[allow(dead_code)]
struct DefineAnalysisSchemeResponseDeserializer;
impl DefineAnalysisSchemeResponseDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DefineAnalysisSchemeResponse, XmlParseError> {
deserialize_elements::<_, DefineAnalysisSchemeResponse, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"AnalysisScheme" => {
obj.analysis_scheme =
AnalysisSchemeStatusDeserializer::deserialize("AnalysisScheme", stack)?;
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DefineExpressionRequest {
pub domain_name: String,
pub expression: Expression,
}
struct DefineExpressionRequestSerializer;
impl DefineExpressionRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DefineExpressionRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(&format!("{}{}", prefix, "DomainName"), &obj.domain_name);
ExpressionSerializer::serialize(
params,
&format!("{}{}", prefix, "Expression"),
&obj.expression,
);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct DefineExpressionResponse {
pub expression: ExpressionStatus,
}
#[allow(dead_code)]
struct DefineExpressionResponseDeserializer;
impl DefineExpressionResponseDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DefineExpressionResponse, XmlParseError> {
deserialize_elements::<_, DefineExpressionResponse, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"Expression" => {
obj.expression =
ExpressionStatusDeserializer::deserialize("Expression", stack)?;
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DefineIndexFieldRequest {
pub domain_name: String,
pub index_field: IndexField,
}
struct DefineIndexFieldRequestSerializer;
impl DefineIndexFieldRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DefineIndexFieldRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(&format!("{}{}", prefix, "DomainName"), &obj.domain_name);
IndexFieldSerializer::serialize(
params,
&format!("{}{}", prefix, "IndexField"),
&obj.index_field,
);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct DefineIndexFieldResponse {
pub index_field: IndexFieldStatus,
}
#[allow(dead_code)]
struct DefineIndexFieldResponseDeserializer;
impl DefineIndexFieldResponseDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DefineIndexFieldResponse, XmlParseError> {
deserialize_elements::<_, DefineIndexFieldResponse, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"IndexField" => {
obj.index_field =
IndexFieldStatusDeserializer::deserialize("IndexField", stack)?;
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DefineSuggesterRequest {
pub domain_name: String,
pub suggester: Suggester,
}
struct DefineSuggesterRequestSerializer;
impl DefineSuggesterRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DefineSuggesterRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(&format!("{}{}", prefix, "DomainName"), &obj.domain_name);
SuggesterSerializer::serialize(
params,
&format!("{}{}", prefix, "Suggester"),
&obj.suggester,
);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct DefineSuggesterResponse {
pub suggester: SuggesterStatus,
}
#[allow(dead_code)]
struct DefineSuggesterResponseDeserializer;
impl DefineSuggesterResponseDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DefineSuggesterResponse, XmlParseError> {
deserialize_elements::<_, DefineSuggesterResponse, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"Suggester" => {
obj.suggester =
SuggesterStatusDeserializer::deserialize("Suggester", stack)?;
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteAnalysisSchemeRequest {
pub analysis_scheme_name: String,
pub domain_name: String,
}
struct DeleteAnalysisSchemeRequestSerializer;
impl DeleteAnalysisSchemeRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DeleteAnalysisSchemeRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "AnalysisSchemeName"),
&obj.analysis_scheme_name,
);
params.put(&format!("{}{}", prefix, "DomainName"), &obj.domain_name);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct DeleteAnalysisSchemeResponse {
pub analysis_scheme: AnalysisSchemeStatus,
}
#[allow(dead_code)]
struct DeleteAnalysisSchemeResponseDeserializer;
impl DeleteAnalysisSchemeResponseDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DeleteAnalysisSchemeResponse, XmlParseError> {
deserialize_elements::<_, DeleteAnalysisSchemeResponse, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"AnalysisScheme" => {
obj.analysis_scheme =
AnalysisSchemeStatusDeserializer::deserialize("AnalysisScheme", stack)?;
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteDomainRequest {
pub domain_name: String,
}
struct DeleteDomainRequestSerializer;
impl DeleteDomainRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DeleteDomainRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(&format!("{}{}", prefix, "DomainName"), &obj.domain_name);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct DeleteDomainResponse {
pub domain_status: Option<DomainStatus>,
}
#[allow(dead_code)]
struct DeleteDomainResponseDeserializer;
impl DeleteDomainResponseDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DeleteDomainResponse, XmlParseError> {
deserialize_elements::<_, DeleteDomainResponse, _>(tag_name, stack, |name, stack, obj| {
match name {
"DomainStatus" => {
obj.domain_status = Some(DomainStatusDeserializer::deserialize(
"DomainStatus",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteExpressionRequest {
pub domain_name: String,
pub expression_name: String,
}
struct DeleteExpressionRequestSerializer;
impl DeleteExpressionRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DeleteExpressionRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(&format!("{}{}", prefix, "DomainName"), &obj.domain_name);
params.put(
&format!("{}{}", prefix, "ExpressionName"),
&obj.expression_name,
);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct DeleteExpressionResponse {
pub expression: ExpressionStatus,
}
#[allow(dead_code)]
struct DeleteExpressionResponseDeserializer;
impl DeleteExpressionResponseDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DeleteExpressionResponse, XmlParseError> {
deserialize_elements::<_, DeleteExpressionResponse, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"Expression" => {
obj.expression =
ExpressionStatusDeserializer::deserialize("Expression", stack)?;
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteIndexFieldRequest {
pub domain_name: String,
pub index_field_name: String,
}
struct DeleteIndexFieldRequestSerializer;
impl DeleteIndexFieldRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DeleteIndexFieldRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(&format!("{}{}", prefix, "DomainName"), &obj.domain_name);
params.put(
&format!("{}{}", prefix, "IndexFieldName"),
&obj.index_field_name,
);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct DeleteIndexFieldResponse {
pub index_field: IndexFieldStatus,
}
#[allow(dead_code)]
struct DeleteIndexFieldResponseDeserializer;
impl DeleteIndexFieldResponseDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DeleteIndexFieldResponse, XmlParseError> {
deserialize_elements::<_, DeleteIndexFieldResponse, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"IndexField" => {
obj.index_field =
IndexFieldStatusDeserializer::deserialize("IndexField", stack)?;
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteSuggesterRequest {
pub domain_name: String,
pub suggester_name: String,
}
struct DeleteSuggesterRequestSerializer;
impl DeleteSuggesterRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DeleteSuggesterRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(&format!("{}{}", prefix, "DomainName"), &obj.domain_name);
params.put(
&format!("{}{}", prefix, "SuggesterName"),
&obj.suggester_name,
);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct DeleteSuggesterResponse {
pub suggester: SuggesterStatus,
}
#[allow(dead_code)]
struct DeleteSuggesterResponseDeserializer;
impl DeleteSuggesterResponseDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DeleteSuggesterResponse, XmlParseError> {
deserialize_elements::<_, DeleteSuggesterResponse, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"Suggester" => {
obj.suggester =
SuggesterStatusDeserializer::deserialize("Suggester", stack)?;
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeAnalysisSchemesRequest {
pub analysis_scheme_names: Option<Vec<String>>,
pub deployed: Option<bool>,
pub domain_name: String,
}
struct DescribeAnalysisSchemesRequestSerializer;
impl DescribeAnalysisSchemesRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeAnalysisSchemesRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.analysis_scheme_names {
StandardNameListSerializer::serialize(
params,
&format!("{}{}", prefix, "AnalysisSchemeNames"),
field_value,
);
}
if let Some(ref field_value) = obj.deployed {
params.put(&format!("{}{}", prefix, "Deployed"), &field_value);
}
params.put(&format!("{}{}", prefix, "DomainName"), &obj.domain_name);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct DescribeAnalysisSchemesResponse {
pub analysis_schemes: Vec<AnalysisSchemeStatus>,
}
#[allow(dead_code)]
struct DescribeAnalysisSchemesResponseDeserializer;
impl DescribeAnalysisSchemesResponseDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeAnalysisSchemesResponse, XmlParseError> {
deserialize_elements::<_, DescribeAnalysisSchemesResponse, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"AnalysisSchemes" => {
obj.analysis_schemes.extend(
AnalysisSchemeStatusListDeserializer::deserialize(
"AnalysisSchemes",
stack,
)?,
);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeAvailabilityOptionsRequest {
pub deployed: Option<bool>,
pub domain_name: String,
}
struct DescribeAvailabilityOptionsRequestSerializer;
impl DescribeAvailabilityOptionsRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeAvailabilityOptionsRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.deployed {
params.put(&format!("{}{}", prefix, "Deployed"), &field_value);
}
params.put(&format!("{}{}", prefix, "DomainName"), &obj.domain_name);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct DescribeAvailabilityOptionsResponse {
pub availability_options: Option<AvailabilityOptionsStatus>,
}
#[allow(dead_code)]
struct DescribeAvailabilityOptionsResponseDeserializer;
impl DescribeAvailabilityOptionsResponseDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeAvailabilityOptionsResponse, XmlParseError> {
deserialize_elements::<_, DescribeAvailabilityOptionsResponse, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"AvailabilityOptions" => {
obj.availability_options =
Some(AvailabilityOptionsStatusDeserializer::deserialize(
"AvailabilityOptions",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeDomainEndpointOptionsRequest {
pub deployed: Option<bool>,
pub domain_name: String,
}
struct DescribeDomainEndpointOptionsRequestSerializer;
impl DescribeDomainEndpointOptionsRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeDomainEndpointOptionsRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.deployed {
params.put(&format!("{}{}", prefix, "Deployed"), &field_value);
}
params.put(&format!("{}{}", prefix, "DomainName"), &obj.domain_name);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct DescribeDomainEndpointOptionsResponse {
pub domain_endpoint_options: Option<DomainEndpointOptionsStatus>,
}
#[allow(dead_code)]
struct DescribeDomainEndpointOptionsResponseDeserializer;
impl DescribeDomainEndpointOptionsResponseDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeDomainEndpointOptionsResponse, XmlParseError> {
deserialize_elements::<_, DescribeDomainEndpointOptionsResponse, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"DomainEndpointOptions" => {
obj.domain_endpoint_options =
Some(DomainEndpointOptionsStatusDeserializer::deserialize(
"DomainEndpointOptions",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeDomainsRequest {
pub domain_names: Option<Vec<String>>,
}
struct DescribeDomainsRequestSerializer;
impl DescribeDomainsRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeDomainsRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.domain_names {
DomainNameListSerializer::serialize(
params,
&format!("{}{}", prefix, "DomainNames"),
field_value,
);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct DescribeDomainsResponse {
pub domain_status_list: Vec<DomainStatus>,
}
#[allow(dead_code)]
struct DescribeDomainsResponseDeserializer;
impl DescribeDomainsResponseDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeDomainsResponse, XmlParseError> {
deserialize_elements::<_, DescribeDomainsResponse, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"DomainStatusList" => {
obj.domain_status_list
.extend(DomainStatusListDeserializer::deserialize(
"DomainStatusList",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeExpressionsRequest {
pub deployed: Option<bool>,
pub domain_name: String,
pub expression_names: Option<Vec<String>>,
}
struct DescribeExpressionsRequestSerializer;
impl DescribeExpressionsRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeExpressionsRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.deployed {
params.put(&format!("{}{}", prefix, "Deployed"), &field_value);
}
params.put(&format!("{}{}", prefix, "DomainName"), &obj.domain_name);
if let Some(ref field_value) = obj.expression_names {
StandardNameListSerializer::serialize(
params,
&format!("{}{}", prefix, "ExpressionNames"),
field_value,
);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct DescribeExpressionsResponse {
pub expressions: Vec<ExpressionStatus>,
}
#[allow(dead_code)]
struct DescribeExpressionsResponseDeserializer;
impl DescribeExpressionsResponseDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeExpressionsResponse, XmlParseError> {
deserialize_elements::<_, DescribeExpressionsResponse, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"Expressions" => {
obj.expressions
.extend(ExpressionStatusListDeserializer::deserialize(
"Expressions",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeIndexFieldsRequest {
pub deployed: Option<bool>,
pub domain_name: String,
pub field_names: Option<Vec<String>>,
}
struct DescribeIndexFieldsRequestSerializer;
impl DescribeIndexFieldsRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeIndexFieldsRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.deployed {
params.put(&format!("{}{}", prefix, "Deployed"), &field_value);
}
params.put(&format!("{}{}", prefix, "DomainName"), &obj.domain_name);
if let Some(ref field_value) = obj.field_names {
DynamicFieldNameListSerializer::serialize(
params,
&format!("{}{}", prefix, "FieldNames"),
field_value,
);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct DescribeIndexFieldsResponse {
pub index_fields: Vec<IndexFieldStatus>,
}
#[allow(dead_code)]
struct DescribeIndexFieldsResponseDeserializer;
impl DescribeIndexFieldsResponseDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeIndexFieldsResponse, XmlParseError> {
deserialize_elements::<_, DescribeIndexFieldsResponse, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"IndexFields" => {
obj.index_fields
.extend(IndexFieldStatusListDeserializer::deserialize(
"IndexFields",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeScalingParametersRequest {
pub domain_name: String,
}
struct DescribeScalingParametersRequestSerializer;
impl DescribeScalingParametersRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeScalingParametersRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(&format!("{}{}", prefix, "DomainName"), &obj.domain_name);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct DescribeScalingParametersResponse {
pub scaling_parameters: ScalingParametersStatus,
}
#[allow(dead_code)]
struct DescribeScalingParametersResponseDeserializer;
impl DescribeScalingParametersResponseDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeScalingParametersResponse, XmlParseError> {
deserialize_elements::<_, DescribeScalingParametersResponse, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"ScalingParameters" => {
obj.scaling_parameters = ScalingParametersStatusDeserializer::deserialize(
"ScalingParameters",
stack,
)?;
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeServiceAccessPoliciesRequest {
pub deployed: Option<bool>,
pub domain_name: String,
}
struct DescribeServiceAccessPoliciesRequestSerializer;
impl DescribeServiceAccessPoliciesRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeServiceAccessPoliciesRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.deployed {
params.put(&format!("{}{}", prefix, "Deployed"), &field_value);
}
params.put(&format!("{}{}", prefix, "DomainName"), &obj.domain_name);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct DescribeServiceAccessPoliciesResponse {
pub access_policies: AccessPoliciesStatus,
}
#[allow(dead_code)]
struct DescribeServiceAccessPoliciesResponseDeserializer;
impl DescribeServiceAccessPoliciesResponseDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeServiceAccessPoliciesResponse, XmlParseError> {
deserialize_elements::<_, DescribeServiceAccessPoliciesResponse, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"AccessPolicies" => {
obj.access_policies =
AccessPoliciesStatusDeserializer::deserialize("AccessPolicies", stack)?;
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeSuggestersRequest {
pub deployed: Option<bool>,
pub domain_name: String,
pub suggester_names: Option<Vec<String>>,
}
struct DescribeSuggestersRequestSerializer;
impl DescribeSuggestersRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeSuggestersRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.deployed {
params.put(&format!("{}{}", prefix, "Deployed"), &field_value);
}
params.put(&format!("{}{}", prefix, "DomainName"), &obj.domain_name);
if let Some(ref field_value) = obj.suggester_names {
StandardNameListSerializer::serialize(
params,
&format!("{}{}", prefix, "SuggesterNames"),
field_value,
);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct DescribeSuggestersResponse {
pub suggesters: Vec<SuggesterStatus>,
}
#[allow(dead_code)]
struct DescribeSuggestersResponseDeserializer;
impl DescribeSuggestersResponseDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeSuggestersResponse, XmlParseError> {
deserialize_elements::<_, DescribeSuggestersResponse, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"Suggesters" => {
obj.suggesters
.extend(SuggesterStatusListDeserializer::deserialize(
"Suggesters",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DocumentSuggesterOptions {
pub fuzzy_matching: Option<String>,
pub sort_expression: Option<String>,
pub source_field: String,
}
#[allow(dead_code)]
struct DocumentSuggesterOptionsDeserializer;
impl DocumentSuggesterOptionsDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DocumentSuggesterOptions, XmlParseError> {
deserialize_elements::<_, DocumentSuggesterOptions, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"FuzzyMatching" => {
obj.fuzzy_matching = Some(SuggesterFuzzyMatchingDeserializer::deserialize(
"FuzzyMatching",
stack,
)?);
}
"SortExpression" => {
obj.sort_expression =
Some(StringDeserializer::deserialize("SortExpression", stack)?);
}
"SourceField" => {
obj.source_field =
FieldNameDeserializer::deserialize("SourceField", stack)?;
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
struct DocumentSuggesterOptionsSerializer;
impl DocumentSuggesterOptionsSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DocumentSuggesterOptions) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.fuzzy_matching {
params.put(&format!("{}{}", prefix, "FuzzyMatching"), &field_value);
}
if let Some(ref field_value) = obj.sort_expression {
params.put(&format!("{}{}", prefix, "SortExpression"), &field_value);
}
params.put(&format!("{}{}", prefix, "SourceField"), &obj.source_field);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DomainEndpointOptions {
pub enforce_https: Option<bool>,
pub tls_security_policy: Option<String>,
}
#[allow(dead_code)]
struct DomainEndpointOptionsDeserializer;
impl DomainEndpointOptionsDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DomainEndpointOptions, XmlParseError> {
deserialize_elements::<_, DomainEndpointOptions, _>(tag_name, stack, |name, stack, obj| {
match name {
"EnforceHTTPS" => {
obj.enforce_https =
Some(BooleanDeserializer::deserialize("EnforceHTTPS", stack)?);
}
"TLSSecurityPolicy" => {
obj.tls_security_policy = Some(TLSSecurityPolicyDeserializer::deserialize(
"TLSSecurityPolicy",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct DomainEndpointOptionsSerializer;
impl DomainEndpointOptionsSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DomainEndpointOptions) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.enforce_https {
params.put(&format!("{}{}", prefix, "EnforceHTTPS"), &field_value);
}
if let Some(ref field_value) = obj.tls_security_policy {
params.put(&format!("{}{}", prefix, "TLSSecurityPolicy"), &field_value);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct DomainEndpointOptionsStatus {
pub options: DomainEndpointOptions,
pub status: OptionStatus,
}
#[allow(dead_code)]
struct DomainEndpointOptionsStatusDeserializer;
impl DomainEndpointOptionsStatusDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DomainEndpointOptionsStatus, XmlParseError> {
deserialize_elements::<_, DomainEndpointOptionsStatus, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"Options" => {
obj.options =
DomainEndpointOptionsDeserializer::deserialize("Options", stack)?;
}
"Status" => {
obj.status = OptionStatusDeserializer::deserialize("Status", stack)?;
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[allow(dead_code)]
struct DomainIdDeserializer;
impl DomainIdDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct DomainNameDeserializer;
impl DomainNameDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
struct DomainNameListSerializer;
impl DomainNameListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.member.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
#[allow(dead_code)]
struct DomainNameMapDeserializer;
impl DomainNameMapDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<::std::collections::HashMap<String, String>, XmlParseError> {
xml_util::start_element(tag_name, stack)?;
let mut obj = ::std::collections::HashMap::new();
while xml_util::peek_at_name(stack)? == "entry" {
xml_util::start_element("entry", stack)?;
let key = DomainNameDeserializer::deserialize("key", stack)?;
let value = APIVersionDeserializer::deserialize("value", stack)?;
obj.insert(key, value);
xml_util::end_element("entry", stack)?;
}
xml_util::end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct DomainStatus {
pub arn: Option<String>,
pub created: Option<bool>,
pub deleted: Option<bool>,
pub doc_service: Option<ServiceEndpoint>,
pub domain_id: String,
pub domain_name: String,
pub limits: Option<Limits>,
pub processing: Option<bool>,
pub requires_index_documents: bool,
pub search_instance_count: Option<i64>,
pub search_instance_type: Option<String>,
pub search_partition_count: Option<i64>,
pub search_service: Option<ServiceEndpoint>,
}
#[allow(dead_code)]
struct DomainStatusDeserializer;
impl DomainStatusDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DomainStatus, XmlParseError> {
deserialize_elements::<_, DomainStatus, _>(tag_name, stack, |name, stack, obj| {
match name {
"ARN" => {
obj.arn = Some(ARNDeserializer::deserialize("ARN", stack)?);
}
"Created" => {
obj.created = Some(BooleanDeserializer::deserialize("Created", stack)?);
}
"Deleted" => {
obj.deleted = Some(BooleanDeserializer::deserialize("Deleted", stack)?);
}
"DocService" => {
obj.doc_service = Some(ServiceEndpointDeserializer::deserialize(
"DocService",
stack,
)?);
}
"DomainId" => {
obj.domain_id = DomainIdDeserializer::deserialize("DomainId", stack)?;
}
"DomainName" => {
obj.domain_name = DomainNameDeserializer::deserialize("DomainName", stack)?;
}
"Limits" => {
obj.limits = Some(LimitsDeserializer::deserialize("Limits", stack)?);
}
"Processing" => {
obj.processing = Some(BooleanDeserializer::deserialize("Processing", stack)?);
}
"RequiresIndexDocuments" => {
obj.requires_index_documents =
BooleanDeserializer::deserialize("RequiresIndexDocuments", stack)?;
}
"SearchInstanceCount" => {
obj.search_instance_count = Some(InstanceCountDeserializer::deserialize(
"SearchInstanceCount",
stack,
)?);
}
"SearchInstanceType" => {
obj.search_instance_type = Some(SearchInstanceTypeDeserializer::deserialize(
"SearchInstanceType",
stack,
)?);
}
"SearchPartitionCount" => {
obj.search_partition_count = Some(PartitionCountDeserializer::deserialize(
"SearchPartitionCount",
stack,
)?);
}
"SearchService" => {
obj.search_service = Some(ServiceEndpointDeserializer::deserialize(
"SearchService",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[allow(dead_code)]
struct DomainStatusListDeserializer;
impl DomainStatusListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<DomainStatus>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "member" {
obj.push(DomainStatusDeserializer::deserialize("member", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[allow(dead_code)]
struct DoubleDeserializer;
impl DoubleDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<f64, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, |s| Ok(f64::from_str(&s).unwrap()))
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DoubleArrayOptions {
pub default_value: Option<f64>,
pub facet_enabled: Option<bool>,
pub return_enabled: Option<bool>,
pub search_enabled: Option<bool>,
pub source_fields: Option<String>,
}
#[allow(dead_code)]
struct DoubleArrayOptionsDeserializer;
impl DoubleArrayOptionsDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DoubleArrayOptions, XmlParseError> {
deserialize_elements::<_, DoubleArrayOptions, _>(tag_name, stack, |name, stack, obj| {
match name {
"DefaultValue" => {
obj.default_value =
Some(DoubleDeserializer::deserialize("DefaultValue", stack)?);
}
"FacetEnabled" => {
obj.facet_enabled =
Some(BooleanDeserializer::deserialize("FacetEnabled", stack)?);
}
"ReturnEnabled" => {
obj.return_enabled =
Some(BooleanDeserializer::deserialize("ReturnEnabled", stack)?);
}
"SearchEnabled" => {
obj.search_enabled =
Some(BooleanDeserializer::deserialize("SearchEnabled", stack)?);
}
"SourceFields" => {
obj.source_fields = Some(FieldNameCommaListDeserializer::deserialize(
"SourceFields",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct DoubleArrayOptionsSerializer;
impl DoubleArrayOptionsSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DoubleArrayOptions) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.default_value {
params.put(&format!("{}{}", prefix, "DefaultValue"), &field_value);
}
if let Some(ref field_value) = obj.facet_enabled {
params.put(&format!("{}{}", prefix, "FacetEnabled"), &field_value);
}
if let Some(ref field_value) = obj.return_enabled {
params.put(&format!("{}{}", prefix, "ReturnEnabled"), &field_value);
}
if let Some(ref field_value) = obj.search_enabled {
params.put(&format!("{}{}", prefix, "SearchEnabled"), &field_value);
}
if let Some(ref field_value) = obj.source_fields {
params.put(&format!("{}{}", prefix, "SourceFields"), &field_value);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DoubleOptions {
pub default_value: Option<f64>,
pub facet_enabled: Option<bool>,
pub return_enabled: Option<bool>,
pub search_enabled: Option<bool>,
pub sort_enabled: Option<bool>,
pub source_field: Option<String>,
}
#[allow(dead_code)]
struct DoubleOptionsDeserializer;
impl DoubleOptionsDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DoubleOptions, XmlParseError> {
deserialize_elements::<_, DoubleOptions, _>(tag_name, stack, |name, stack, obj| {
match name {
"DefaultValue" => {
obj.default_value =
Some(DoubleDeserializer::deserialize("DefaultValue", stack)?);
}
"FacetEnabled" => {
obj.facet_enabled =
Some(BooleanDeserializer::deserialize("FacetEnabled", stack)?);
}
"ReturnEnabled" => {
obj.return_enabled =
Some(BooleanDeserializer::deserialize("ReturnEnabled", stack)?);
}
"SearchEnabled" => {
obj.search_enabled =
Some(BooleanDeserializer::deserialize("SearchEnabled", stack)?);
}
"SortEnabled" => {
obj.sort_enabled =
Some(BooleanDeserializer::deserialize("SortEnabled", stack)?);
}
"SourceField" => {
obj.source_field =
Some(FieldNameDeserializer::deserialize("SourceField", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct DoubleOptionsSerializer;
impl DoubleOptionsSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DoubleOptions) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.default_value {
params.put(&format!("{}{}", prefix, "DefaultValue"), &field_value);
}
if let Some(ref field_value) = obj.facet_enabled {
params.put(&format!("{}{}", prefix, "FacetEnabled"), &field_value);
}
if let Some(ref field_value) = obj.return_enabled {
params.put(&format!("{}{}", prefix, "ReturnEnabled"), &field_value);
}
if let Some(ref field_value) = obj.search_enabled {
params.put(&format!("{}{}", prefix, "SearchEnabled"), &field_value);
}
if let Some(ref field_value) = obj.sort_enabled {
params.put(&format!("{}{}", prefix, "SortEnabled"), &field_value);
}
if let Some(ref field_value) = obj.source_field {
params.put(&format!("{}{}", prefix, "SourceField"), &field_value);
}
}
}
#[allow(dead_code)]
struct DynamicFieldNameDeserializer;
impl DynamicFieldNameDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
struct DynamicFieldNameListSerializer;
impl DynamicFieldNameListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.member.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct Expression {
pub expression_name: String,
pub expression_value: String,
}
#[allow(dead_code)]
struct ExpressionDeserializer;
impl ExpressionDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Expression, XmlParseError> {
deserialize_elements::<_, Expression, _>(tag_name, stack, |name, stack, obj| {
match name {
"ExpressionName" => {
obj.expression_name =
StandardNameDeserializer::deserialize("ExpressionName", stack)?;
}
"ExpressionValue" => {
obj.expression_value =
ExpressionValueDeserializer::deserialize("ExpressionValue", stack)?;
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct ExpressionSerializer;
impl ExpressionSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Expression) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "ExpressionName"),
&obj.expression_name,
);
params.put(
&format!("{}{}", prefix, "ExpressionValue"),
&obj.expression_value,
);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct ExpressionStatus {
pub options: Expression,
pub status: OptionStatus,
}
#[allow(dead_code)]
struct ExpressionStatusDeserializer;
impl ExpressionStatusDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ExpressionStatus, XmlParseError> {
deserialize_elements::<_, ExpressionStatus, _>(tag_name, stack, |name, stack, obj| {
match name {
"Options" => {
obj.options = ExpressionDeserializer::deserialize("Options", stack)?;
}
"Status" => {
obj.status = OptionStatusDeserializer::deserialize("Status", stack)?;
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[allow(dead_code)]
struct ExpressionStatusListDeserializer;
impl ExpressionStatusListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<ExpressionStatus>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "member" {
obj.push(ExpressionStatusDeserializer::deserialize("member", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[allow(dead_code)]
struct ExpressionValueDeserializer;
impl ExpressionValueDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct FieldNameDeserializer;
impl FieldNameDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct FieldNameCommaListDeserializer;
impl FieldNameCommaListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct FieldNameListDeserializer;
impl FieldNameListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<String>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "member" {
obj.push(FieldNameDeserializer::deserialize("member", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[allow(dead_code)]
struct FieldValueDeserializer;
impl FieldValueDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct IndexDocumentsRequest {
pub domain_name: String,
}
struct IndexDocumentsRequestSerializer;
impl IndexDocumentsRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &IndexDocumentsRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(&format!("{}{}", prefix, "DomainName"), &obj.domain_name);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct IndexDocumentsResponse {
pub field_names: Option<Vec<String>>,
}
#[allow(dead_code)]
struct IndexDocumentsResponseDeserializer;
impl IndexDocumentsResponseDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<IndexDocumentsResponse, XmlParseError> {
deserialize_elements::<_, IndexDocumentsResponse, _>(tag_name, stack, |name, stack, obj| {
match name {
"FieldNames" => {
obj.field_names
.get_or_insert(vec![])
.extend(FieldNameListDeserializer::deserialize("FieldNames", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct IndexField {
pub date_array_options: Option<DateArrayOptions>,
pub date_options: Option<DateOptions>,
pub double_array_options: Option<DoubleArrayOptions>,
pub double_options: Option<DoubleOptions>,
pub index_field_name: String,
pub index_field_type: String,
pub int_array_options: Option<IntArrayOptions>,
pub int_options: Option<IntOptions>,
pub lat_lon_options: Option<LatLonOptions>,
pub literal_array_options: Option<LiteralArrayOptions>,
pub literal_options: Option<LiteralOptions>,
pub text_array_options: Option<TextArrayOptions>,
pub text_options: Option<TextOptions>,
}
#[allow(dead_code)]
struct IndexFieldDeserializer;
impl IndexFieldDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<IndexField, XmlParseError> {
deserialize_elements::<_, IndexField, _>(tag_name, stack, |name, stack, obj| {
match name {
"DateArrayOptions" => {
obj.date_array_options = Some(DateArrayOptionsDeserializer::deserialize(
"DateArrayOptions",
stack,
)?);
}
"DateOptions" => {
obj.date_options =
Some(DateOptionsDeserializer::deserialize("DateOptions", stack)?);
}
"DoubleArrayOptions" => {
obj.double_array_options = Some(DoubleArrayOptionsDeserializer::deserialize(
"DoubleArrayOptions",
stack,
)?);
}
"DoubleOptions" => {
obj.double_options = Some(DoubleOptionsDeserializer::deserialize(
"DoubleOptions",
stack,
)?);
}
"IndexFieldName" => {
obj.index_field_name =
DynamicFieldNameDeserializer::deserialize("IndexFieldName", stack)?;
}
"IndexFieldType" => {
obj.index_field_type =
IndexFieldTypeDeserializer::deserialize("IndexFieldType", stack)?;
}
"IntArrayOptions" => {
obj.int_array_options = Some(IntArrayOptionsDeserializer::deserialize(
"IntArrayOptions",
stack,
)?);
}
"IntOptions" => {
obj.int_options =
Some(IntOptionsDeserializer::deserialize("IntOptions", stack)?);
}
"LatLonOptions" => {
obj.lat_lon_options = Some(LatLonOptionsDeserializer::deserialize(
"LatLonOptions",
stack,
)?);
}
"LiteralArrayOptions" => {
obj.literal_array_options = Some(LiteralArrayOptionsDeserializer::deserialize(
"LiteralArrayOptions",
stack,
)?);
}
"LiteralOptions" => {
obj.literal_options = Some(LiteralOptionsDeserializer::deserialize(
"LiteralOptions",
stack,
)?);
}
"TextArrayOptions" => {
obj.text_array_options = Some(TextArrayOptionsDeserializer::deserialize(
"TextArrayOptions",
stack,
)?);
}
"TextOptions" => {
obj.text_options =
Some(TextOptionsDeserializer::deserialize("TextOptions", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct IndexFieldSerializer;
impl IndexFieldSerializer {
fn serialize(params: &mut Params, name: &str, obj: &IndexField) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.date_array_options {
DateArrayOptionsSerializer::serialize(
params,
&format!("{}{}", prefix, "DateArrayOptions"),
field_value,
);
}
if let Some(ref field_value) = obj.date_options {
DateOptionsSerializer::serialize(
params,
&format!("{}{}", prefix, "DateOptions"),
field_value,
);
}
if let Some(ref field_value) = obj.double_array_options {
DoubleArrayOptionsSerializer::serialize(
params,
&format!("{}{}", prefix, "DoubleArrayOptions"),
field_value,
);
}
if let Some(ref field_value) = obj.double_options {
DoubleOptionsSerializer::serialize(
params,
&format!("{}{}", prefix, "DoubleOptions"),
field_value,
);
}
params.put(
&format!("{}{}", prefix, "IndexFieldName"),
&obj.index_field_name,
);
params.put(
&format!("{}{}", prefix, "IndexFieldType"),
&obj.index_field_type,
);
if let Some(ref field_value) = obj.int_array_options {
IntArrayOptionsSerializer::serialize(
params,
&format!("{}{}", prefix, "IntArrayOptions"),
field_value,
);
}
if let Some(ref field_value) = obj.int_options {
IntOptionsSerializer::serialize(
params,
&format!("{}{}", prefix, "IntOptions"),
field_value,
);
}
if let Some(ref field_value) = obj.lat_lon_options {
LatLonOptionsSerializer::serialize(
params,
&format!("{}{}", prefix, "LatLonOptions"),
field_value,
);
}
if let Some(ref field_value) = obj.literal_array_options {
LiteralArrayOptionsSerializer::serialize(
params,
&format!("{}{}", prefix, "LiteralArrayOptions"),
field_value,
);
}
if let Some(ref field_value) = obj.literal_options {
LiteralOptionsSerializer::serialize(
params,
&format!("{}{}", prefix, "LiteralOptions"),
field_value,
);
}
if let Some(ref field_value) = obj.text_array_options {
TextArrayOptionsSerializer::serialize(
params,
&format!("{}{}", prefix, "TextArrayOptions"),
field_value,
);
}
if let Some(ref field_value) = obj.text_options {
TextOptionsSerializer::serialize(
params,
&format!("{}{}", prefix, "TextOptions"),
field_value,
);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct IndexFieldStatus {
pub options: IndexField,
pub status: OptionStatus,
}
#[allow(dead_code)]
struct IndexFieldStatusDeserializer;
impl IndexFieldStatusDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<IndexFieldStatus, XmlParseError> {
deserialize_elements::<_, IndexFieldStatus, _>(tag_name, stack, |name, stack, obj| {
match name {
"Options" => {
obj.options = IndexFieldDeserializer::deserialize("Options", stack)?;
}
"Status" => {
obj.status = OptionStatusDeserializer::deserialize("Status", stack)?;
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[allow(dead_code)]
struct IndexFieldStatusListDeserializer;
impl IndexFieldStatusListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<IndexFieldStatus>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "member" {
obj.push(IndexFieldStatusDeserializer::deserialize("member", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[allow(dead_code)]
struct IndexFieldTypeDeserializer;
impl IndexFieldTypeDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct InstanceCountDeserializer;
impl InstanceCountDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<i64, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, |s| Ok(i64::from_str(&s).unwrap()))
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct IntArrayOptions {
pub default_value: Option<i64>,
pub facet_enabled: Option<bool>,
pub return_enabled: Option<bool>,
pub search_enabled: Option<bool>,
pub source_fields: Option<String>,
}
#[allow(dead_code)]
struct IntArrayOptionsDeserializer;
impl IntArrayOptionsDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<IntArrayOptions, XmlParseError> {
deserialize_elements::<_, IntArrayOptions, _>(tag_name, stack, |name, stack, obj| {
match name {
"DefaultValue" => {
obj.default_value = Some(LongDeserializer::deserialize("DefaultValue", stack)?);
}
"FacetEnabled" => {
obj.facet_enabled =
Some(BooleanDeserializer::deserialize("FacetEnabled", stack)?);
}
"ReturnEnabled" => {
obj.return_enabled =
Some(BooleanDeserializer::deserialize("ReturnEnabled", stack)?);
}
"SearchEnabled" => {
obj.search_enabled =
Some(BooleanDeserializer::deserialize("SearchEnabled", stack)?);
}
"SourceFields" => {
obj.source_fields = Some(FieldNameCommaListDeserializer::deserialize(
"SourceFields",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct IntArrayOptionsSerializer;
impl IntArrayOptionsSerializer {
fn serialize(params: &mut Params, name: &str, obj: &IntArrayOptions) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.default_value {
params.put(&format!("{}{}", prefix, "DefaultValue"), &field_value);
}
if let Some(ref field_value) = obj.facet_enabled {
params.put(&format!("{}{}", prefix, "FacetEnabled"), &field_value);
}
if let Some(ref field_value) = obj.return_enabled {
params.put(&format!("{}{}", prefix, "ReturnEnabled"), &field_value);
}
if let Some(ref field_value) = obj.search_enabled {
params.put(&format!("{}{}", prefix, "SearchEnabled"), &field_value);
}
if let Some(ref field_value) = obj.source_fields {
params.put(&format!("{}{}", prefix, "SourceFields"), &field_value);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct IntOptions {
pub default_value: Option<i64>,
pub facet_enabled: Option<bool>,
pub return_enabled: Option<bool>,
pub search_enabled: Option<bool>,
pub sort_enabled: Option<bool>,
pub source_field: Option<String>,
}
#[allow(dead_code)]
struct IntOptionsDeserializer;
impl IntOptionsDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<IntOptions, XmlParseError> {
deserialize_elements::<_, IntOptions, _>(tag_name, stack, |name, stack, obj| {
match name {
"DefaultValue" => {
obj.default_value = Some(LongDeserializer::deserialize("DefaultValue", stack)?);
}
"FacetEnabled" => {
obj.facet_enabled =
Some(BooleanDeserializer::deserialize("FacetEnabled", stack)?);
}
"ReturnEnabled" => {
obj.return_enabled =
Some(BooleanDeserializer::deserialize("ReturnEnabled", stack)?);
}
"SearchEnabled" => {
obj.search_enabled =
Some(BooleanDeserializer::deserialize("SearchEnabled", stack)?);
}
"SortEnabled" => {
obj.sort_enabled =
Some(BooleanDeserializer::deserialize("SortEnabled", stack)?);
}
"SourceField" => {
obj.source_field =
Some(FieldNameDeserializer::deserialize("SourceField", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct IntOptionsSerializer;
impl IntOptionsSerializer {
fn serialize(params: &mut Params, name: &str, obj: &IntOptions) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.default_value {
params.put(&format!("{}{}", prefix, "DefaultValue"), &field_value);
}
if let Some(ref field_value) = obj.facet_enabled {
params.put(&format!("{}{}", prefix, "FacetEnabled"), &field_value);
}
if let Some(ref field_value) = obj.return_enabled {
params.put(&format!("{}{}", prefix, "ReturnEnabled"), &field_value);
}
if let Some(ref field_value) = obj.search_enabled {
params.put(&format!("{}{}", prefix, "SearchEnabled"), &field_value);
}
if let Some(ref field_value) = obj.sort_enabled {
params.put(&format!("{}{}", prefix, "SortEnabled"), &field_value);
}
if let Some(ref field_value) = obj.source_field {
params.put(&format!("{}{}", prefix, "SourceField"), &field_value);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct LatLonOptions {
pub default_value: Option<String>,
pub facet_enabled: Option<bool>,
pub return_enabled: Option<bool>,
pub search_enabled: Option<bool>,
pub sort_enabled: Option<bool>,
pub source_field: Option<String>,
}
#[allow(dead_code)]
struct LatLonOptionsDeserializer;
impl LatLonOptionsDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<LatLonOptions, XmlParseError> {
deserialize_elements::<_, LatLonOptions, _>(tag_name, stack, |name, stack, obj| {
match name {
"DefaultValue" => {
obj.default_value =
Some(FieldValueDeserializer::deserialize("DefaultValue", stack)?);
}
"FacetEnabled" => {
obj.facet_enabled =
Some(BooleanDeserializer::deserialize("FacetEnabled", stack)?);
}
"ReturnEnabled" => {
obj.return_enabled =
Some(BooleanDeserializer::deserialize("ReturnEnabled", stack)?);
}
"SearchEnabled" => {
obj.search_enabled =
Some(BooleanDeserializer::deserialize("SearchEnabled", stack)?);
}
"SortEnabled" => {
obj.sort_enabled =
Some(BooleanDeserializer::deserialize("SortEnabled", stack)?);
}
"SourceField" => {
obj.source_field =
Some(FieldNameDeserializer::deserialize("SourceField", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct LatLonOptionsSerializer;
impl LatLonOptionsSerializer {
fn serialize(params: &mut Params, name: &str, obj: &LatLonOptions) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.default_value {
params.put(&format!("{}{}", prefix, "DefaultValue"), &field_value);
}
if let Some(ref field_value) = obj.facet_enabled {
params.put(&format!("{}{}", prefix, "FacetEnabled"), &field_value);
}
if let Some(ref field_value) = obj.return_enabled {
params.put(&format!("{}{}", prefix, "ReturnEnabled"), &field_value);
}
if let Some(ref field_value) = obj.search_enabled {
params.put(&format!("{}{}", prefix, "SearchEnabled"), &field_value);
}
if let Some(ref field_value) = obj.sort_enabled {
params.put(&format!("{}{}", prefix, "SortEnabled"), &field_value);
}
if let Some(ref field_value) = obj.source_field {
params.put(&format!("{}{}", prefix, "SourceField"), &field_value);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct Limits {
pub maximum_partition_count: i64,
pub maximum_replication_count: i64,
}
#[allow(dead_code)]
struct LimitsDeserializer;
impl LimitsDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<Limits, XmlParseError> {
deserialize_elements::<_, Limits, _>(tag_name, stack, |name, stack, obj| {
match name {
"MaximumPartitionCount" => {
obj.maximum_partition_count = MaximumPartitionCountDeserializer::deserialize(
"MaximumPartitionCount",
stack,
)?;
}
"MaximumReplicationCount" => {
obj.maximum_replication_count =
MaximumReplicationCountDeserializer::deserialize(
"MaximumReplicationCount",
stack,
)?;
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct ListDomainNamesResponse {
pub domain_names: Option<::std::collections::HashMap<String, String>>,
}
#[allow(dead_code)]
struct ListDomainNamesResponseDeserializer;
impl ListDomainNamesResponseDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ListDomainNamesResponse, XmlParseError> {
deserialize_elements::<_, ListDomainNamesResponse, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"DomainNames" => {
obj.domain_names = Some(DomainNameMapDeserializer::deserialize(
"DomainNames",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct LiteralArrayOptions {
pub default_value: Option<String>,
pub facet_enabled: Option<bool>,
pub return_enabled: Option<bool>,
pub search_enabled: Option<bool>,
pub source_fields: Option<String>,
}
#[allow(dead_code)]
struct LiteralArrayOptionsDeserializer;
impl LiteralArrayOptionsDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<LiteralArrayOptions, XmlParseError> {
deserialize_elements::<_, LiteralArrayOptions, _>(tag_name, stack, |name, stack, obj| {
match name {
"DefaultValue" => {
obj.default_value =
Some(FieldValueDeserializer::deserialize("DefaultValue", stack)?);
}
"FacetEnabled" => {
obj.facet_enabled =
Some(BooleanDeserializer::deserialize("FacetEnabled", stack)?);
}
"ReturnEnabled" => {
obj.return_enabled =
Some(BooleanDeserializer::deserialize("ReturnEnabled", stack)?);
}
"SearchEnabled" => {
obj.search_enabled =
Some(BooleanDeserializer::deserialize("SearchEnabled", stack)?);
}
"SourceFields" => {
obj.source_fields = Some(FieldNameCommaListDeserializer::deserialize(
"SourceFields",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct LiteralArrayOptionsSerializer;
impl LiteralArrayOptionsSerializer {
fn serialize(params: &mut Params, name: &str, obj: &LiteralArrayOptions) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.default_value {
params.put(&format!("{}{}", prefix, "DefaultValue"), &field_value);
}
if let Some(ref field_value) = obj.facet_enabled {
params.put(&format!("{}{}", prefix, "FacetEnabled"), &field_value);
}
if let Some(ref field_value) = obj.return_enabled {
params.put(&format!("{}{}", prefix, "ReturnEnabled"), &field_value);
}
if let Some(ref field_value) = obj.search_enabled {
params.put(&format!("{}{}", prefix, "SearchEnabled"), &field_value);
}
if let Some(ref field_value) = obj.source_fields {
params.put(&format!("{}{}", prefix, "SourceFields"), &field_value);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct LiteralOptions {
pub default_value: Option<String>,
pub facet_enabled: Option<bool>,
pub return_enabled: Option<bool>,
pub search_enabled: Option<bool>,
pub sort_enabled: Option<bool>,
pub source_field: Option<String>,
}
#[allow(dead_code)]
struct LiteralOptionsDeserializer;
impl LiteralOptionsDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<LiteralOptions, XmlParseError> {
deserialize_elements::<_, LiteralOptions, _>(tag_name, stack, |name, stack, obj| {
match name {
"DefaultValue" => {
obj.default_value =
Some(FieldValueDeserializer::deserialize("DefaultValue", stack)?);
}
"FacetEnabled" => {
obj.facet_enabled =
Some(BooleanDeserializer::deserialize("FacetEnabled", stack)?);
}
"ReturnEnabled" => {
obj.return_enabled =
Some(BooleanDeserializer::deserialize("ReturnEnabled", stack)?);
}
"SearchEnabled" => {
obj.search_enabled =
Some(BooleanDeserializer::deserialize("SearchEnabled", stack)?);
}
"SortEnabled" => {
obj.sort_enabled =
Some(BooleanDeserializer::deserialize("SortEnabled", stack)?);
}
"SourceField" => {
obj.source_field =
Some(FieldNameDeserializer::deserialize("SourceField", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct LiteralOptionsSerializer;
impl LiteralOptionsSerializer {
fn serialize(params: &mut Params, name: &str, obj: &LiteralOptions) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.default_value {
params.put(&format!("{}{}", prefix, "DefaultValue"), &field_value);
}
if let Some(ref field_value) = obj.facet_enabled {
params.put(&format!("{}{}", prefix, "FacetEnabled"), &field_value);
}
if let Some(ref field_value) = obj.return_enabled {
params.put(&format!("{}{}", prefix, "ReturnEnabled"), &field_value);
}
if let Some(ref field_value) = obj.search_enabled {
params.put(&format!("{}{}", prefix, "SearchEnabled"), &field_value);
}
if let Some(ref field_value) = obj.sort_enabled {
params.put(&format!("{}{}", prefix, "SortEnabled"), &field_value);
}
if let Some(ref field_value) = obj.source_field {
params.put(&format!("{}{}", prefix, "SourceField"), &field_value);
}
}
}
#[allow(dead_code)]
struct LongDeserializer;
impl LongDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<i64, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, |s| Ok(i64::from_str(&s).unwrap()))
}
}
#[allow(dead_code)]
struct MaximumPartitionCountDeserializer;
impl MaximumPartitionCountDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<i64, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, |s| Ok(i64::from_str(&s).unwrap()))
}
}
#[allow(dead_code)]
struct MaximumReplicationCountDeserializer;
impl MaximumReplicationCountDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<i64, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, |s| Ok(i64::from_str(&s).unwrap()))
}
}
#[allow(dead_code)]
struct MultiAZDeserializer;
impl MultiAZDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<bool, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, |s| Ok(bool::from_str(&s).unwrap()))
}
}
#[allow(dead_code)]
struct OptionStateDeserializer;
impl OptionStateDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct OptionStatus {
pub creation_date: String,
pub pending_deletion: Option<bool>,
pub state: String,
pub update_date: String,
pub update_version: Option<i64>,
}
#[allow(dead_code)]
struct OptionStatusDeserializer;
impl OptionStatusDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<OptionStatus, XmlParseError> {
deserialize_elements::<_, OptionStatus, _>(tag_name, stack, |name, stack, obj| {
match name {
"CreationDate" => {
obj.creation_date =
UpdateTimestampDeserializer::deserialize("CreationDate", stack)?;
}
"PendingDeletion" => {
obj.pending_deletion =
Some(BooleanDeserializer::deserialize("PendingDeletion", stack)?);
}
"State" => {
obj.state = OptionStateDeserializer::deserialize("State", stack)?;
}
"UpdateDate" => {
obj.update_date =
UpdateTimestampDeserializer::deserialize("UpdateDate", stack)?;
}
"UpdateVersion" => {
obj.update_version =
Some(UIntValueDeserializer::deserialize("UpdateVersion", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[allow(dead_code)]
struct PartitionCountDeserializer;
impl PartitionCountDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<i64, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, |s| Ok(i64::from_str(&s).unwrap()))
}
}
#[allow(dead_code)]
struct PartitionInstanceTypeDeserializer;
impl PartitionInstanceTypeDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct PolicyDocumentDeserializer;
impl PolicyDocumentDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ScalingParameters {
pub desired_instance_type: Option<String>,
pub desired_partition_count: Option<i64>,
pub desired_replication_count: Option<i64>,
}
#[allow(dead_code)]
struct ScalingParametersDeserializer;
impl ScalingParametersDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ScalingParameters, XmlParseError> {
deserialize_elements::<_, ScalingParameters, _>(tag_name, stack, |name, stack, obj| {
match name {
"DesiredInstanceType" => {
obj.desired_instance_type =
Some(PartitionInstanceTypeDeserializer::deserialize(
"DesiredInstanceType",
stack,
)?);
}
"DesiredPartitionCount" => {
obj.desired_partition_count = Some(UIntValueDeserializer::deserialize(
"DesiredPartitionCount",
stack,
)?);
}
"DesiredReplicationCount" => {
obj.desired_replication_count = Some(UIntValueDeserializer::deserialize(
"DesiredReplicationCount",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct ScalingParametersSerializer;
impl ScalingParametersSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ScalingParameters) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.desired_instance_type {
params.put(
&format!("{}{}", prefix, "DesiredInstanceType"),
&field_value,
);
}
if let Some(ref field_value) = obj.desired_partition_count {
params.put(
&format!("{}{}", prefix, "DesiredPartitionCount"),
&field_value,
);
}
if let Some(ref field_value) = obj.desired_replication_count {
params.put(
&format!("{}{}", prefix, "DesiredReplicationCount"),
&field_value,
);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct ScalingParametersStatus {
pub options: ScalingParameters,
pub status: OptionStatus,
}
#[allow(dead_code)]
struct ScalingParametersStatusDeserializer;
impl ScalingParametersStatusDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ScalingParametersStatus, XmlParseError> {
deserialize_elements::<_, ScalingParametersStatus, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"Options" => {
obj.options = ScalingParametersDeserializer::deserialize("Options", stack)?;
}
"Status" => {
obj.status = OptionStatusDeserializer::deserialize("Status", stack)?;
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[allow(dead_code)]
struct SearchInstanceTypeDeserializer;
impl SearchInstanceTypeDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct ServiceEndpoint {
pub endpoint: Option<String>,
}
#[allow(dead_code)]
struct ServiceEndpointDeserializer;
impl ServiceEndpointDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ServiceEndpoint, XmlParseError> {
deserialize_elements::<_, ServiceEndpoint, _>(tag_name, stack, |name, stack, obj| {
match name {
"Endpoint" => {
obj.endpoint = Some(ServiceUrlDeserializer::deserialize("Endpoint", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[allow(dead_code)]
struct ServiceUrlDeserializer;
impl ServiceUrlDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct StandardNameDeserializer;
impl StandardNameDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
struct StandardNameListSerializer;
impl StandardNameListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.member.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
#[allow(dead_code)]
struct StringDeserializer;
impl StringDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct Suggester {
pub document_suggester_options: DocumentSuggesterOptions,
pub suggester_name: String,
}
#[allow(dead_code)]
struct SuggesterDeserializer;
impl SuggesterDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Suggester, XmlParseError> {
deserialize_elements::<_, Suggester, _>(tag_name, stack, |name, stack, obj| {
match name {
"DocumentSuggesterOptions" => {
obj.document_suggester_options =
DocumentSuggesterOptionsDeserializer::deserialize(
"DocumentSuggesterOptions",
stack,
)?;
}
"SuggesterName" => {
obj.suggester_name =
StandardNameDeserializer::deserialize("SuggesterName", stack)?;
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct SuggesterSerializer;
impl SuggesterSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Suggester) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
DocumentSuggesterOptionsSerializer::serialize(
params,
&format!("{}{}", prefix, "DocumentSuggesterOptions"),
&obj.document_suggester_options,
);
params.put(
&format!("{}{}", prefix, "SuggesterName"),
&obj.suggester_name,
);
}
}
#[allow(dead_code)]
struct SuggesterFuzzyMatchingDeserializer;
impl SuggesterFuzzyMatchingDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct SuggesterStatus {
pub options: Suggester,
pub status: OptionStatus,
}
#[allow(dead_code)]
struct SuggesterStatusDeserializer;
impl SuggesterStatusDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<SuggesterStatus, XmlParseError> {
deserialize_elements::<_, SuggesterStatus, _>(tag_name, stack, |name, stack, obj| {
match name {
"Options" => {
obj.options = SuggesterDeserializer::deserialize("Options", stack)?;
}
"Status" => {
obj.status = OptionStatusDeserializer::deserialize("Status", stack)?;
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[allow(dead_code)]
struct SuggesterStatusListDeserializer;
impl SuggesterStatusListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<SuggesterStatus>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "member" {
obj.push(SuggesterStatusDeserializer::deserialize("member", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[allow(dead_code)]
struct TLSSecurityPolicyDeserializer;
impl TLSSecurityPolicyDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct TextArrayOptions {
pub analysis_scheme: Option<String>,
pub default_value: Option<String>,
pub highlight_enabled: Option<bool>,
pub return_enabled: Option<bool>,
pub source_fields: Option<String>,
}
#[allow(dead_code)]
struct TextArrayOptionsDeserializer;
impl TextArrayOptionsDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<TextArrayOptions, XmlParseError> {
deserialize_elements::<_, TextArrayOptions, _>(tag_name, stack, |name, stack, obj| {
match name {
"AnalysisScheme" => {
obj.analysis_scheme =
Some(WordDeserializer::deserialize("AnalysisScheme", stack)?);
}
"DefaultValue" => {
obj.default_value =
Some(FieldValueDeserializer::deserialize("DefaultValue", stack)?);
}
"HighlightEnabled" => {
obj.highlight_enabled =
Some(BooleanDeserializer::deserialize("HighlightEnabled", stack)?);
}
"ReturnEnabled" => {
obj.return_enabled =
Some(BooleanDeserializer::deserialize("ReturnEnabled", stack)?);
}
"SourceFields" => {
obj.source_fields = Some(FieldNameCommaListDeserializer::deserialize(
"SourceFields",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct TextArrayOptionsSerializer;
impl TextArrayOptionsSerializer {
fn serialize(params: &mut Params, name: &str, obj: &TextArrayOptions) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.analysis_scheme {
params.put(&format!("{}{}", prefix, "AnalysisScheme"), &field_value);
}
if let Some(ref field_value) = obj.default_value {
params.put(&format!("{}{}", prefix, "DefaultValue"), &field_value);
}
if let Some(ref field_value) = obj.highlight_enabled {
params.put(&format!("{}{}", prefix, "HighlightEnabled"), &field_value);
}
if let Some(ref field_value) = obj.return_enabled {
params.put(&format!("{}{}", prefix, "ReturnEnabled"), &field_value);
}
if let Some(ref field_value) = obj.source_fields {
params.put(&format!("{}{}", prefix, "SourceFields"), &field_value);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct TextOptions {
pub analysis_scheme: Option<String>,
pub default_value: Option<String>,
pub highlight_enabled: Option<bool>,
pub return_enabled: Option<bool>,
pub sort_enabled: Option<bool>,
pub source_field: Option<String>,
}
#[allow(dead_code)]
struct TextOptionsDeserializer;
impl TextOptionsDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<TextOptions, XmlParseError> {
deserialize_elements::<_, TextOptions, _>(tag_name, stack, |name, stack, obj| {
match name {
"AnalysisScheme" => {
obj.analysis_scheme =
Some(WordDeserializer::deserialize("AnalysisScheme", stack)?);
}
"DefaultValue" => {
obj.default_value =
Some(FieldValueDeserializer::deserialize("DefaultValue", stack)?);
}
"HighlightEnabled" => {
obj.highlight_enabled =
Some(BooleanDeserializer::deserialize("HighlightEnabled", stack)?);
}
"ReturnEnabled" => {
obj.return_enabled =
Some(BooleanDeserializer::deserialize("ReturnEnabled", stack)?);
}
"SortEnabled" => {
obj.sort_enabled =
Some(BooleanDeserializer::deserialize("SortEnabled", stack)?);
}
"SourceField" => {
obj.source_field =
Some(FieldNameDeserializer::deserialize("SourceField", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct TextOptionsSerializer;
impl TextOptionsSerializer {
fn serialize(params: &mut Params, name: &str, obj: &TextOptions) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.analysis_scheme {
params.put(&format!("{}{}", prefix, "AnalysisScheme"), &field_value);
}
if let Some(ref field_value) = obj.default_value {
params.put(&format!("{}{}", prefix, "DefaultValue"), &field_value);
}
if let Some(ref field_value) = obj.highlight_enabled {
params.put(&format!("{}{}", prefix, "HighlightEnabled"), &field_value);
}
if let Some(ref field_value) = obj.return_enabled {
params.put(&format!("{}{}", prefix, "ReturnEnabled"), &field_value);
}
if let Some(ref field_value) = obj.sort_enabled {
params.put(&format!("{}{}", prefix, "SortEnabled"), &field_value);
}
if let Some(ref field_value) = obj.source_field {
params.put(&format!("{}{}", prefix, "SourceField"), &field_value);
}
}
}
#[allow(dead_code)]
struct UIntValueDeserializer;
impl UIntValueDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<i64, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, |s| Ok(i64::from_str(&s).unwrap()))
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateAvailabilityOptionsRequest {
pub domain_name: String,
pub multi_az: bool,
}
struct UpdateAvailabilityOptionsRequestSerializer;
impl UpdateAvailabilityOptionsRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &UpdateAvailabilityOptionsRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(&format!("{}{}", prefix, "DomainName"), &obj.domain_name);
params.put(&format!("{}{}", prefix, "MultiAZ"), &obj.multi_az);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct UpdateAvailabilityOptionsResponse {
pub availability_options: Option<AvailabilityOptionsStatus>,
}
#[allow(dead_code)]
struct UpdateAvailabilityOptionsResponseDeserializer;
impl UpdateAvailabilityOptionsResponseDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<UpdateAvailabilityOptionsResponse, XmlParseError> {
deserialize_elements::<_, UpdateAvailabilityOptionsResponse, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"AvailabilityOptions" => {
obj.availability_options =
Some(AvailabilityOptionsStatusDeserializer::deserialize(
"AvailabilityOptions",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateDomainEndpointOptionsRequest {
pub domain_endpoint_options: DomainEndpointOptions,
pub domain_name: String,
}
struct UpdateDomainEndpointOptionsRequestSerializer;
impl UpdateDomainEndpointOptionsRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &UpdateDomainEndpointOptionsRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
DomainEndpointOptionsSerializer::serialize(
params,
&format!("{}{}", prefix, "DomainEndpointOptions"),
&obj.domain_endpoint_options,
);
params.put(&format!("{}{}", prefix, "DomainName"), &obj.domain_name);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct UpdateDomainEndpointOptionsResponse {
pub domain_endpoint_options: Option<DomainEndpointOptionsStatus>,
}
#[allow(dead_code)]
struct UpdateDomainEndpointOptionsResponseDeserializer;
impl UpdateDomainEndpointOptionsResponseDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<UpdateDomainEndpointOptionsResponse, XmlParseError> {
deserialize_elements::<_, UpdateDomainEndpointOptionsResponse, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"DomainEndpointOptions" => {
obj.domain_endpoint_options =
Some(DomainEndpointOptionsStatusDeserializer::deserialize(
"DomainEndpointOptions",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateScalingParametersRequest {
pub domain_name: String,
pub scaling_parameters: ScalingParameters,
}
struct UpdateScalingParametersRequestSerializer;
impl UpdateScalingParametersRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &UpdateScalingParametersRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(&format!("{}{}", prefix, "DomainName"), &obj.domain_name);
ScalingParametersSerializer::serialize(
params,
&format!("{}{}", prefix, "ScalingParameters"),
&obj.scaling_parameters,
);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct UpdateScalingParametersResponse {
pub scaling_parameters: ScalingParametersStatus,
}
#[allow(dead_code)]
struct UpdateScalingParametersResponseDeserializer;
impl UpdateScalingParametersResponseDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<UpdateScalingParametersResponse, XmlParseError> {
deserialize_elements::<_, UpdateScalingParametersResponse, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"ScalingParameters" => {
obj.scaling_parameters = ScalingParametersStatusDeserializer::deserialize(
"ScalingParameters",
stack,
)?;
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateServiceAccessPoliciesRequest {
pub access_policies: String,
pub domain_name: String,
}
struct UpdateServiceAccessPoliciesRequestSerializer;
impl UpdateServiceAccessPoliciesRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &UpdateServiceAccessPoliciesRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "AccessPolicies"),
&obj.access_policies,
);
params.put(&format!("{}{}", prefix, "DomainName"), &obj.domain_name);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct UpdateServiceAccessPoliciesResponse {
pub access_policies: AccessPoliciesStatus,
}
#[allow(dead_code)]
struct UpdateServiceAccessPoliciesResponseDeserializer;
impl UpdateServiceAccessPoliciesResponseDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<UpdateServiceAccessPoliciesResponse, XmlParseError> {
deserialize_elements::<_, UpdateServiceAccessPoliciesResponse, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"AccessPolicies" => {
obj.access_policies =
AccessPoliciesStatusDeserializer::deserialize("AccessPolicies", stack)?;
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[allow(dead_code)]
struct UpdateTimestampDeserializer;
impl UpdateTimestampDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct WordDeserializer;
impl WordDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[derive(Debug, PartialEq)]
pub enum BuildSuggestersError {
Base(String),
Internal(String),
ResourceNotFound(String),
}
impl BuildSuggestersError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<BuildSuggestersError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"BaseException" => {
return RusotoError::Service(BuildSuggestersError::Base(
parsed_error.message,
))
}
"InternalException" => {
return RusotoError::Service(BuildSuggestersError::Internal(
parsed_error.message,
))
}
"ResourceNotFound" => {
return RusotoError::Service(BuildSuggestersError::ResourceNotFound(
parsed_error.message,
))
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for BuildSuggestersError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
BuildSuggestersError::Base(ref cause) => write!(f, "{}", cause),
BuildSuggestersError::Internal(ref cause) => write!(f, "{}", cause),
BuildSuggestersError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for BuildSuggestersError {}
#[derive(Debug, PartialEq)]
pub enum CreateDomainError {
Base(String),
Internal(String),
LimitExceeded(String),
}
impl CreateDomainError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateDomainError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"BaseException" => {
return RusotoError::Service(CreateDomainError::Base(parsed_error.message))
}
"InternalException" => {
return RusotoError::Service(CreateDomainError::Internal(
parsed_error.message,
))
}
"LimitExceeded" => {
return RusotoError::Service(CreateDomainError::LimitExceeded(
parsed_error.message,
))
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for CreateDomainError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateDomainError::Base(ref cause) => write!(f, "{}", cause),
CreateDomainError::Internal(ref cause) => write!(f, "{}", cause),
CreateDomainError::LimitExceeded(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateDomainError {}
#[derive(Debug, PartialEq)]
pub enum DefineAnalysisSchemeError {
Base(String),
Internal(String),
InvalidType(String),
LimitExceeded(String),
ResourceNotFound(String),
}
impl DefineAnalysisSchemeError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DefineAnalysisSchemeError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"BaseException" => {
return RusotoError::Service(DefineAnalysisSchemeError::Base(
parsed_error.message,
))
}
"InternalException" => {
return RusotoError::Service(DefineAnalysisSchemeError::Internal(
parsed_error.message,
))
}
"InvalidType" => {
return RusotoError::Service(DefineAnalysisSchemeError::InvalidType(
parsed_error.message,
))
}
"LimitExceeded" => {
return RusotoError::Service(DefineAnalysisSchemeError::LimitExceeded(
parsed_error.message,
))
}
"ResourceNotFound" => {
return RusotoError::Service(DefineAnalysisSchemeError::ResourceNotFound(
parsed_error.message,
))
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DefineAnalysisSchemeError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DefineAnalysisSchemeError::Base(ref cause) => write!(f, "{}", cause),
DefineAnalysisSchemeError::Internal(ref cause) => write!(f, "{}", cause),
DefineAnalysisSchemeError::InvalidType(ref cause) => write!(f, "{}", cause),
DefineAnalysisSchemeError::LimitExceeded(ref cause) => write!(f, "{}", cause),
DefineAnalysisSchemeError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DefineAnalysisSchemeError {}
#[derive(Debug, PartialEq)]
pub enum DefineExpressionError {
Base(String),
Internal(String),
InvalidType(String),
LimitExceeded(String),
ResourceNotFound(String),
}
impl DefineExpressionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DefineExpressionError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"BaseException" => {
return RusotoError::Service(DefineExpressionError::Base(
parsed_error.message,
))
}
"InternalException" => {
return RusotoError::Service(DefineExpressionError::Internal(
parsed_error.message,
))
}
"InvalidType" => {
return RusotoError::Service(DefineExpressionError::InvalidType(
parsed_error.message,
))
}
"LimitExceeded" => {
return RusotoError::Service(DefineExpressionError::LimitExceeded(
parsed_error.message,
))
}
"ResourceNotFound" => {
return RusotoError::Service(DefineExpressionError::ResourceNotFound(
parsed_error.message,
))
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DefineExpressionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DefineExpressionError::Base(ref cause) => write!(f, "{}", cause),
DefineExpressionError::Internal(ref cause) => write!(f, "{}", cause),
DefineExpressionError::InvalidType(ref cause) => write!(f, "{}", cause),
DefineExpressionError::LimitExceeded(ref cause) => write!(f, "{}", cause),
DefineExpressionError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DefineExpressionError {}
#[derive(Debug, PartialEq)]
pub enum DefineIndexFieldError {
Base(String),
Internal(String),
InvalidType(String),
LimitExceeded(String),
ResourceNotFound(String),
}
impl DefineIndexFieldError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DefineIndexFieldError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"BaseException" => {
return RusotoError::Service(DefineIndexFieldError::Base(
parsed_error.message,
))
}
"InternalException" => {
return RusotoError::Service(DefineIndexFieldError::Internal(
parsed_error.message,
))
}
"InvalidType" => {
return RusotoError::Service(DefineIndexFieldError::InvalidType(
parsed_error.message,
))
}
"LimitExceeded" => {
return RusotoError::Service(DefineIndexFieldError::LimitExceeded(
parsed_error.message,
))
}
"ResourceNotFound" => {
return RusotoError::Service(DefineIndexFieldError::ResourceNotFound(
parsed_error.message,
))
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DefineIndexFieldError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DefineIndexFieldError::Base(ref cause) => write!(f, "{}", cause),
DefineIndexFieldError::Internal(ref cause) => write!(f, "{}", cause),
DefineIndexFieldError::InvalidType(ref cause) => write!(f, "{}", cause),
DefineIndexFieldError::LimitExceeded(ref cause) => write!(f, "{}", cause),
DefineIndexFieldError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DefineIndexFieldError {}
#[derive(Debug, PartialEq)]
pub enum DefineSuggesterError {
Base(String),
Internal(String),
InvalidType(String),
LimitExceeded(String),
ResourceNotFound(String),
}
impl DefineSuggesterError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DefineSuggesterError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"BaseException" => {
return RusotoError::Service(DefineSuggesterError::Base(
parsed_error.message,
))
}
"InternalException" => {
return RusotoError::Service(DefineSuggesterError::Internal(
parsed_error.message,
))
}
"InvalidType" => {
return RusotoError::Service(DefineSuggesterError::InvalidType(
parsed_error.message,
))
}
"LimitExceeded" => {
return RusotoError::Service(DefineSuggesterError::LimitExceeded(
parsed_error.message,
))
}
"ResourceNotFound" => {
return RusotoError::Service(DefineSuggesterError::ResourceNotFound(
parsed_error.message,
))
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DefineSuggesterError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DefineSuggesterError::Base(ref cause) => write!(f, "{}", cause),
DefineSuggesterError::Internal(ref cause) => write!(f, "{}", cause),
DefineSuggesterError::InvalidType(ref cause) => write!(f, "{}", cause),
DefineSuggesterError::LimitExceeded(ref cause) => write!(f, "{}", cause),
DefineSuggesterError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DefineSuggesterError {}
#[derive(Debug, PartialEq)]
pub enum DeleteAnalysisSchemeError {
Base(String),
Internal(String),
InvalidType(String),
ResourceNotFound(String),
}
impl DeleteAnalysisSchemeError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteAnalysisSchemeError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"BaseException" => {
return RusotoError::Service(DeleteAnalysisSchemeError::Base(
parsed_error.message,
))
}
"InternalException" => {
return RusotoError::Service(DeleteAnalysisSchemeError::Internal(
parsed_error.message,
))
}
"InvalidType" => {
return RusotoError::Service(DeleteAnalysisSchemeError::InvalidType(
parsed_error.message,
))
}
"ResourceNotFound" => {
return RusotoError::Service(DeleteAnalysisSchemeError::ResourceNotFound(
parsed_error.message,
))
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DeleteAnalysisSchemeError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteAnalysisSchemeError::Base(ref cause) => write!(f, "{}", cause),
DeleteAnalysisSchemeError::Internal(ref cause) => write!(f, "{}", cause),
DeleteAnalysisSchemeError::InvalidType(ref cause) => write!(f, "{}", cause),
DeleteAnalysisSchemeError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteAnalysisSchemeError {}
#[derive(Debug, PartialEq)]
pub enum DeleteDomainError {
Base(String),
Internal(String),
}
impl DeleteDomainError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteDomainError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"BaseException" => {
return RusotoError::Service(DeleteDomainError::Base(parsed_error.message))
}
"InternalException" => {
return RusotoError::Service(DeleteDomainError::Internal(
parsed_error.message,
))
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DeleteDomainError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteDomainError::Base(ref cause) => write!(f, "{}", cause),
DeleteDomainError::Internal(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteDomainError {}
#[derive(Debug, PartialEq)]
pub enum DeleteExpressionError {
Base(String),
Internal(String),
InvalidType(String),
ResourceNotFound(String),
}
impl DeleteExpressionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteExpressionError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"BaseException" => {
return RusotoError::Service(DeleteExpressionError::Base(
parsed_error.message,
))
}
"InternalException" => {
return RusotoError::Service(DeleteExpressionError::Internal(
parsed_error.message,
))
}
"InvalidType" => {
return RusotoError::Service(DeleteExpressionError::InvalidType(
parsed_error.message,
))
}
"ResourceNotFound" => {
return RusotoError::Service(DeleteExpressionError::ResourceNotFound(
parsed_error.message,
))
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DeleteExpressionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteExpressionError::Base(ref cause) => write!(f, "{}", cause),
DeleteExpressionError::Internal(ref cause) => write!(f, "{}", cause),
DeleteExpressionError::InvalidType(ref cause) => write!(f, "{}", cause),
DeleteExpressionError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteExpressionError {}
#[derive(Debug, PartialEq)]
pub enum DeleteIndexFieldError {
Base(String),
Internal(String),
InvalidType(String),
ResourceNotFound(String),
}
impl DeleteIndexFieldError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteIndexFieldError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"BaseException" => {
return RusotoError::Service(DeleteIndexFieldError::Base(
parsed_error.message,
))
}
"InternalException" => {
return RusotoError::Service(DeleteIndexFieldError::Internal(
parsed_error.message,
))
}
"InvalidType" => {
return RusotoError::Service(DeleteIndexFieldError::InvalidType(
parsed_error.message,
))
}
"ResourceNotFound" => {
return RusotoError::Service(DeleteIndexFieldError::ResourceNotFound(
parsed_error.message,
))
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DeleteIndexFieldError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteIndexFieldError::Base(ref cause) => write!(f, "{}", cause),
DeleteIndexFieldError::Internal(ref cause) => write!(f, "{}", cause),
DeleteIndexFieldError::InvalidType(ref cause) => write!(f, "{}", cause),
DeleteIndexFieldError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteIndexFieldError {}
#[derive(Debug, PartialEq)]
pub enum DeleteSuggesterError {
Base(String),
Internal(String),
InvalidType(String),
ResourceNotFound(String),
}
impl DeleteSuggesterError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteSuggesterError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"BaseException" => {
return RusotoError::Service(DeleteSuggesterError::Base(
parsed_error.message,
))
}
"InternalException" => {
return RusotoError::Service(DeleteSuggesterError::Internal(
parsed_error.message,
))
}
"InvalidType" => {
return RusotoError::Service(DeleteSuggesterError::InvalidType(
parsed_error.message,
))
}
"ResourceNotFound" => {
return RusotoError::Service(DeleteSuggesterError::ResourceNotFound(
parsed_error.message,
))
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DeleteSuggesterError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteSuggesterError::Base(ref cause) => write!(f, "{}", cause),
DeleteSuggesterError::Internal(ref cause) => write!(f, "{}", cause),
DeleteSuggesterError::InvalidType(ref cause) => write!(f, "{}", cause),
DeleteSuggesterError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteSuggesterError {}
#[derive(Debug, PartialEq)]
pub enum DescribeAnalysisSchemesError {
Base(String),
Internal(String),
ResourceNotFound(String),
}
impl DescribeAnalysisSchemesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeAnalysisSchemesError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"BaseException" => {
return RusotoError::Service(DescribeAnalysisSchemesError::Base(
parsed_error.message,
))
}
"InternalException" => {
return RusotoError::Service(DescribeAnalysisSchemesError::Internal(
parsed_error.message,
))
}
"ResourceNotFound" => {
return RusotoError::Service(
DescribeAnalysisSchemesError::ResourceNotFound(parsed_error.message),
)
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeAnalysisSchemesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeAnalysisSchemesError::Base(ref cause) => write!(f, "{}", cause),
DescribeAnalysisSchemesError::Internal(ref cause) => write!(f, "{}", cause),
DescribeAnalysisSchemesError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeAnalysisSchemesError {}
#[derive(Debug, PartialEq)]
pub enum DescribeAvailabilityOptionsError {
Base(String),
DisabledOperation(String),
Internal(String),
InvalidType(String),
LimitExceeded(String),
ResourceNotFound(String),
}
impl DescribeAvailabilityOptionsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeAvailabilityOptionsError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"BaseException" => {
return RusotoError::Service(DescribeAvailabilityOptionsError::Base(
parsed_error.message,
))
}
"DisabledAction" => {
return RusotoError::Service(
DescribeAvailabilityOptionsError::DisabledOperation(
parsed_error.message,
),
)
}
"InternalException" => {
return RusotoError::Service(DescribeAvailabilityOptionsError::Internal(
parsed_error.message,
))
}
"InvalidType" => {
return RusotoError::Service(DescribeAvailabilityOptionsError::InvalidType(
parsed_error.message,
))
}
"LimitExceeded" => {
return RusotoError::Service(
DescribeAvailabilityOptionsError::LimitExceeded(parsed_error.message),
)
}
"ResourceNotFound" => {
return RusotoError::Service(
DescribeAvailabilityOptionsError::ResourceNotFound(
parsed_error.message,
),
)
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeAvailabilityOptionsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeAvailabilityOptionsError::Base(ref cause) => write!(f, "{}", cause),
DescribeAvailabilityOptionsError::DisabledOperation(ref cause) => {
write!(f, "{}", cause)
}
DescribeAvailabilityOptionsError::Internal(ref cause) => write!(f, "{}", cause),
DescribeAvailabilityOptionsError::InvalidType(ref cause) => write!(f, "{}", cause),
DescribeAvailabilityOptionsError::LimitExceeded(ref cause) => write!(f, "{}", cause),
DescribeAvailabilityOptionsError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeAvailabilityOptionsError {}
#[derive(Debug, PartialEq)]
pub enum DescribeDomainEndpointOptionsError {
Base(String),
DisabledOperation(String),
Internal(String),
LimitExceeded(String),
ResourceNotFound(String),
}
impl DescribeDomainEndpointOptionsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeDomainEndpointOptionsError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"BaseException" => {
return RusotoError::Service(DescribeDomainEndpointOptionsError::Base(
parsed_error.message,
))
}
"DisabledAction" => {
return RusotoError::Service(
DescribeDomainEndpointOptionsError::DisabledOperation(
parsed_error.message,
),
)
}
"InternalException" => {
return RusotoError::Service(DescribeDomainEndpointOptionsError::Internal(
parsed_error.message,
))
}
"LimitExceeded" => {
return RusotoError::Service(
DescribeDomainEndpointOptionsError::LimitExceeded(parsed_error.message),
)
}
"ResourceNotFound" => {
return RusotoError::Service(
DescribeDomainEndpointOptionsError::ResourceNotFound(
parsed_error.message,
),
)
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeDomainEndpointOptionsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeDomainEndpointOptionsError::Base(ref cause) => write!(f, "{}", cause),
DescribeDomainEndpointOptionsError::DisabledOperation(ref cause) => {
write!(f, "{}", cause)
}
DescribeDomainEndpointOptionsError::Internal(ref cause) => write!(f, "{}", cause),
DescribeDomainEndpointOptionsError::LimitExceeded(ref cause) => write!(f, "{}", cause),
DescribeDomainEndpointOptionsError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DescribeDomainEndpointOptionsError {}
#[derive(Debug, PartialEq)]
pub enum DescribeDomainsError {
Base(String),
Internal(String),
}
impl DescribeDomainsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeDomainsError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"BaseException" => {
return RusotoError::Service(DescribeDomainsError::Base(
parsed_error.message,
))
}
"InternalException" => {
return RusotoError::Service(DescribeDomainsError::Internal(
parsed_error.message,
))
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeDomainsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeDomainsError::Base(ref cause) => write!(f, "{}", cause),
DescribeDomainsError::Internal(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeDomainsError {}
#[derive(Debug, PartialEq)]
pub enum DescribeExpressionsError {
Base(String),
Internal(String),
ResourceNotFound(String),
}
impl DescribeExpressionsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeExpressionsError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"BaseException" => {
return RusotoError::Service(DescribeExpressionsError::Base(
parsed_error.message,
))
}
"InternalException" => {
return RusotoError::Service(DescribeExpressionsError::Internal(
parsed_error.message,
))
}
"ResourceNotFound" => {
return RusotoError::Service(DescribeExpressionsError::ResourceNotFound(
parsed_error.message,
))
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeExpressionsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeExpressionsError::Base(ref cause) => write!(f, "{}", cause),
DescribeExpressionsError::Internal(ref cause) => write!(f, "{}", cause),
DescribeExpressionsError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeExpressionsError {}
#[derive(Debug, PartialEq)]
pub enum DescribeIndexFieldsError {
Base(String),
Internal(String),
ResourceNotFound(String),
}
impl DescribeIndexFieldsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeIndexFieldsError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"BaseException" => {
return RusotoError::Service(DescribeIndexFieldsError::Base(
parsed_error.message,
))
}
"InternalException" => {
return RusotoError::Service(DescribeIndexFieldsError::Internal(
parsed_error.message,
))
}
"ResourceNotFound" => {
return RusotoError::Service(DescribeIndexFieldsError::ResourceNotFound(
parsed_error.message,
))
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeIndexFieldsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeIndexFieldsError::Base(ref cause) => write!(f, "{}", cause),
DescribeIndexFieldsError::Internal(ref cause) => write!(f, "{}", cause),
DescribeIndexFieldsError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeIndexFieldsError {}
#[derive(Debug, PartialEq)]
pub enum DescribeScalingParametersError {
Base(String),
Internal(String),
ResourceNotFound(String),
}
impl DescribeScalingParametersError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeScalingParametersError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"BaseException" => {
return RusotoError::Service(DescribeScalingParametersError::Base(
parsed_error.message,
))
}
"InternalException" => {
return RusotoError::Service(DescribeScalingParametersError::Internal(
parsed_error.message,
))
}
"ResourceNotFound" => {
return RusotoError::Service(
DescribeScalingParametersError::ResourceNotFound(parsed_error.message),
)
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeScalingParametersError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeScalingParametersError::Base(ref cause) => write!(f, "{}", cause),
DescribeScalingParametersError::Internal(ref cause) => write!(f, "{}", cause),
DescribeScalingParametersError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeScalingParametersError {}
#[derive(Debug, PartialEq)]
pub enum DescribeServiceAccessPoliciesError {
Base(String),
Internal(String),
ResourceNotFound(String),
}
impl DescribeServiceAccessPoliciesError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeServiceAccessPoliciesError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"BaseException" => {
return RusotoError::Service(DescribeServiceAccessPoliciesError::Base(
parsed_error.message,
))
}
"InternalException" => {
return RusotoError::Service(DescribeServiceAccessPoliciesError::Internal(
parsed_error.message,
))
}
"ResourceNotFound" => {
return RusotoError::Service(
DescribeServiceAccessPoliciesError::ResourceNotFound(
parsed_error.message,
),
)
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeServiceAccessPoliciesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeServiceAccessPoliciesError::Base(ref cause) => write!(f, "{}", cause),
DescribeServiceAccessPoliciesError::Internal(ref cause) => write!(f, "{}", cause),
DescribeServiceAccessPoliciesError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DescribeServiceAccessPoliciesError {}
#[derive(Debug, PartialEq)]
pub enum DescribeSuggestersError {
Base(String),
Internal(String),
ResourceNotFound(String),
}
impl DescribeSuggestersError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeSuggestersError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"BaseException" => {
return RusotoError::Service(DescribeSuggestersError::Base(
parsed_error.message,
))
}
"InternalException" => {
return RusotoError::Service(DescribeSuggestersError::Internal(
parsed_error.message,
))
}
"ResourceNotFound" => {
return RusotoError::Service(DescribeSuggestersError::ResourceNotFound(
parsed_error.message,
))
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeSuggestersError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeSuggestersError::Base(ref cause) => write!(f, "{}", cause),
DescribeSuggestersError::Internal(ref cause) => write!(f, "{}", cause),
DescribeSuggestersError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeSuggestersError {}
#[derive(Debug, PartialEq)]
pub enum IndexDocumentsError {
Base(String),
Internal(String),
ResourceNotFound(String),
}
impl IndexDocumentsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<IndexDocumentsError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"BaseException" => {
return RusotoError::Service(IndexDocumentsError::Base(
parsed_error.message,
))
}
"InternalException" => {
return RusotoError::Service(IndexDocumentsError::Internal(
parsed_error.message,
))
}
"ResourceNotFound" => {
return RusotoError::Service(IndexDocumentsError::ResourceNotFound(
parsed_error.message,
))
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for IndexDocumentsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
IndexDocumentsError::Base(ref cause) => write!(f, "{}", cause),
IndexDocumentsError::Internal(ref cause) => write!(f, "{}", cause),
IndexDocumentsError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for IndexDocumentsError {}
#[derive(Debug, PartialEq)]
pub enum ListDomainNamesError {
Base(String),
}
impl ListDomainNamesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListDomainNamesError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"BaseException" => {
return RusotoError::Service(ListDomainNamesError::Base(
parsed_error.message,
))
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for ListDomainNamesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListDomainNamesError::Base(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListDomainNamesError {}
#[derive(Debug, PartialEq)]
pub enum UpdateAvailabilityOptionsError {
Base(String),
DisabledOperation(String),
Internal(String),
InvalidType(String),
LimitExceeded(String),
ResourceNotFound(String),
Validation(String),
}
impl UpdateAvailabilityOptionsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateAvailabilityOptionsError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"BaseException" => {
return RusotoError::Service(UpdateAvailabilityOptionsError::Base(
parsed_error.message,
))
}
"DisabledAction" => {
return RusotoError::Service(
UpdateAvailabilityOptionsError::DisabledOperation(parsed_error.message),
)
}
"InternalException" => {
return RusotoError::Service(UpdateAvailabilityOptionsError::Internal(
parsed_error.message,
))
}
"InvalidType" => {
return RusotoError::Service(UpdateAvailabilityOptionsError::InvalidType(
parsed_error.message,
))
}
"LimitExceeded" => {
return RusotoError::Service(UpdateAvailabilityOptionsError::LimitExceeded(
parsed_error.message,
))
}
"ResourceNotFound" => {
return RusotoError::Service(
UpdateAvailabilityOptionsError::ResourceNotFound(parsed_error.message),
)
}
"ValidationException" => {
return RusotoError::Service(UpdateAvailabilityOptionsError::Validation(
parsed_error.message,
))
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for UpdateAvailabilityOptionsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateAvailabilityOptionsError::Base(ref cause) => write!(f, "{}", cause),
UpdateAvailabilityOptionsError::DisabledOperation(ref cause) => write!(f, "{}", cause),
UpdateAvailabilityOptionsError::Internal(ref cause) => write!(f, "{}", cause),
UpdateAvailabilityOptionsError::InvalidType(ref cause) => write!(f, "{}", cause),
UpdateAvailabilityOptionsError::LimitExceeded(ref cause) => write!(f, "{}", cause),
UpdateAvailabilityOptionsError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
UpdateAvailabilityOptionsError::Validation(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateAvailabilityOptionsError {}
#[derive(Debug, PartialEq)]
pub enum UpdateDomainEndpointOptionsError {
Base(String),
DisabledOperation(String),
Internal(String),
InvalidType(String),
LimitExceeded(String),
ResourceNotFound(String),
Validation(String),
}
impl UpdateDomainEndpointOptionsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<UpdateDomainEndpointOptionsError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"BaseException" => {
return RusotoError::Service(UpdateDomainEndpointOptionsError::Base(
parsed_error.message,
))
}
"DisabledAction" => {
return RusotoError::Service(
UpdateDomainEndpointOptionsError::DisabledOperation(
parsed_error.message,
),
)
}
"InternalException" => {
return RusotoError::Service(UpdateDomainEndpointOptionsError::Internal(
parsed_error.message,
))
}
"InvalidType" => {
return RusotoError::Service(UpdateDomainEndpointOptionsError::InvalidType(
parsed_error.message,
))
}
"LimitExceeded" => {
return RusotoError::Service(
UpdateDomainEndpointOptionsError::LimitExceeded(parsed_error.message),
)
}
"ResourceNotFound" => {
return RusotoError::Service(
UpdateDomainEndpointOptionsError::ResourceNotFound(
parsed_error.message,
),
)
}
"ValidationException" => {
return RusotoError::Service(UpdateDomainEndpointOptionsError::Validation(
parsed_error.message,
))
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for UpdateDomainEndpointOptionsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateDomainEndpointOptionsError::Base(ref cause) => write!(f, "{}", cause),
UpdateDomainEndpointOptionsError::DisabledOperation(ref cause) => {
write!(f, "{}", cause)
}
UpdateDomainEndpointOptionsError::Internal(ref cause) => write!(f, "{}", cause),
UpdateDomainEndpointOptionsError::InvalidType(ref cause) => write!(f, "{}", cause),
UpdateDomainEndpointOptionsError::LimitExceeded(ref cause) => write!(f, "{}", cause),
UpdateDomainEndpointOptionsError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
UpdateDomainEndpointOptionsError::Validation(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateDomainEndpointOptionsError {}
#[derive(Debug, PartialEq)]
pub enum UpdateScalingParametersError {
Base(String),
Internal(String),
InvalidType(String),
LimitExceeded(String),
ResourceNotFound(String),
}
impl UpdateScalingParametersError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateScalingParametersError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"BaseException" => {
return RusotoError::Service(UpdateScalingParametersError::Base(
parsed_error.message,
))
}
"InternalException" => {
return RusotoError::Service(UpdateScalingParametersError::Internal(
parsed_error.message,
))
}
"InvalidType" => {
return RusotoError::Service(UpdateScalingParametersError::InvalidType(
parsed_error.message,
))
}
"LimitExceeded" => {
return RusotoError::Service(UpdateScalingParametersError::LimitExceeded(
parsed_error.message,
))
}
"ResourceNotFound" => {
return RusotoError::Service(
UpdateScalingParametersError::ResourceNotFound(parsed_error.message),
)
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for UpdateScalingParametersError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateScalingParametersError::Base(ref cause) => write!(f, "{}", cause),
UpdateScalingParametersError::Internal(ref cause) => write!(f, "{}", cause),
UpdateScalingParametersError::InvalidType(ref cause) => write!(f, "{}", cause),
UpdateScalingParametersError::LimitExceeded(ref cause) => write!(f, "{}", cause),
UpdateScalingParametersError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateScalingParametersError {}
#[derive(Debug, PartialEq)]
pub enum UpdateServiceAccessPoliciesError {
Base(String),
Internal(String),
InvalidType(String),
LimitExceeded(String),
ResourceNotFound(String),
}
impl UpdateServiceAccessPoliciesError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<UpdateServiceAccessPoliciesError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"BaseException" => {
return RusotoError::Service(UpdateServiceAccessPoliciesError::Base(
parsed_error.message,
))
}
"InternalException" => {
return RusotoError::Service(UpdateServiceAccessPoliciesError::Internal(
parsed_error.message,
))
}
"InvalidType" => {
return RusotoError::Service(UpdateServiceAccessPoliciesError::InvalidType(
parsed_error.message,
))
}
"LimitExceeded" => {
return RusotoError::Service(
UpdateServiceAccessPoliciesError::LimitExceeded(parsed_error.message),
)
}
"ResourceNotFound" => {
return RusotoError::Service(
UpdateServiceAccessPoliciesError::ResourceNotFound(
parsed_error.message,
),
)
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for UpdateServiceAccessPoliciesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateServiceAccessPoliciesError::Base(ref cause) => write!(f, "{}", cause),
UpdateServiceAccessPoliciesError::Internal(ref cause) => write!(f, "{}", cause),
UpdateServiceAccessPoliciesError::InvalidType(ref cause) => write!(f, "{}", cause),
UpdateServiceAccessPoliciesError::LimitExceeded(ref cause) => write!(f, "{}", cause),
UpdateServiceAccessPoliciesError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateServiceAccessPoliciesError {}
#[async_trait]
pub trait CloudSearch {
async fn build_suggesters(
&self,
input: BuildSuggestersRequest,
) -> Result<BuildSuggestersResponse, RusotoError<BuildSuggestersError>>;
async fn create_domain(
&self,
input: CreateDomainRequest,
) -> Result<CreateDomainResponse, RusotoError<CreateDomainError>>;
async fn define_analysis_scheme(
&self,
input: DefineAnalysisSchemeRequest,
) -> Result<DefineAnalysisSchemeResponse, RusotoError<DefineAnalysisSchemeError>>;
async fn define_expression(
&self,
input: DefineExpressionRequest,
) -> Result<DefineExpressionResponse, RusotoError<DefineExpressionError>>;
async fn define_index_field(
&self,
input: DefineIndexFieldRequest,
) -> Result<DefineIndexFieldResponse, RusotoError<DefineIndexFieldError>>;
async fn define_suggester(
&self,
input: DefineSuggesterRequest,
) -> Result<DefineSuggesterResponse, RusotoError<DefineSuggesterError>>;
async fn delete_analysis_scheme(
&self,
input: DeleteAnalysisSchemeRequest,
) -> Result<DeleteAnalysisSchemeResponse, RusotoError<DeleteAnalysisSchemeError>>;
async fn delete_domain(
&self,
input: DeleteDomainRequest,
) -> Result<DeleteDomainResponse, RusotoError<DeleteDomainError>>;
async fn delete_expression(
&self,
input: DeleteExpressionRequest,
) -> Result<DeleteExpressionResponse, RusotoError<DeleteExpressionError>>;
async fn delete_index_field(
&self,
input: DeleteIndexFieldRequest,
) -> Result<DeleteIndexFieldResponse, RusotoError<DeleteIndexFieldError>>;
async fn delete_suggester(
&self,
input: DeleteSuggesterRequest,
) -> Result<DeleteSuggesterResponse, RusotoError<DeleteSuggesterError>>;
async fn describe_analysis_schemes(
&self,
input: DescribeAnalysisSchemesRequest,
) -> Result<DescribeAnalysisSchemesResponse, RusotoError<DescribeAnalysisSchemesError>>;
async fn describe_availability_options(
&self,
input: DescribeAvailabilityOptionsRequest,
) -> Result<DescribeAvailabilityOptionsResponse, RusotoError<DescribeAvailabilityOptionsError>>;
async fn describe_domain_endpoint_options(
&self,
input: DescribeDomainEndpointOptionsRequest,
) -> Result<
DescribeDomainEndpointOptionsResponse,
RusotoError<DescribeDomainEndpointOptionsError>,
>;
async fn describe_domains(
&self,
input: DescribeDomainsRequest,
) -> Result<DescribeDomainsResponse, RusotoError<DescribeDomainsError>>;
async fn describe_expressions(
&self,
input: DescribeExpressionsRequest,
) -> Result<DescribeExpressionsResponse, RusotoError<DescribeExpressionsError>>;
async fn describe_index_fields(
&self,
input: DescribeIndexFieldsRequest,
) -> Result<DescribeIndexFieldsResponse, RusotoError<DescribeIndexFieldsError>>;
async fn describe_scaling_parameters(
&self,
input: DescribeScalingParametersRequest,
) -> Result<DescribeScalingParametersResponse, RusotoError<DescribeScalingParametersError>>;
async fn describe_service_access_policies(
&self,
input: DescribeServiceAccessPoliciesRequest,
) -> Result<
DescribeServiceAccessPoliciesResponse,
RusotoError<DescribeServiceAccessPoliciesError>,
>;
async fn describe_suggesters(
&self,
input: DescribeSuggestersRequest,
) -> Result<DescribeSuggestersResponse, RusotoError<DescribeSuggestersError>>;
async fn index_documents(
&self,
input: IndexDocumentsRequest,
) -> Result<IndexDocumentsResponse, RusotoError<IndexDocumentsError>>;
async fn list_domain_names(
&self,
) -> Result<ListDomainNamesResponse, RusotoError<ListDomainNamesError>>;
async fn update_availability_options(
&self,
input: UpdateAvailabilityOptionsRequest,
) -> Result<UpdateAvailabilityOptionsResponse, RusotoError<UpdateAvailabilityOptionsError>>;
async fn update_domain_endpoint_options(
&self,
input: UpdateDomainEndpointOptionsRequest,
) -> Result<UpdateDomainEndpointOptionsResponse, RusotoError<UpdateDomainEndpointOptionsError>>;
async fn update_scaling_parameters(
&self,
input: UpdateScalingParametersRequest,
) -> Result<UpdateScalingParametersResponse, RusotoError<UpdateScalingParametersError>>;
async fn update_service_access_policies(
&self,
input: UpdateServiceAccessPoliciesRequest,
) -> Result<UpdateServiceAccessPoliciesResponse, RusotoError<UpdateServiceAccessPoliciesError>>;
}
#[derive(Clone)]
pub struct CloudSearchClient {
client: Client,
region: region::Region,
}
impl CloudSearchClient {
pub fn new(region: region::Region) -> CloudSearchClient {
CloudSearchClient {
client: Client::shared(),
region,
}
}
pub fn new_with<P, D>(
request_dispatcher: D,
credentials_provider: P,
region: region::Region,
) -> CloudSearchClient
where
P: ProvideAwsCredentials + Send + Sync + 'static,
D: DispatchSignedRequest + Send + Sync + 'static,
{
CloudSearchClient {
client: Client::new_with(credentials_provider, request_dispatcher),
region,
}
}
pub fn new_with_client(client: Client, region: region::Region) -> CloudSearchClient {
CloudSearchClient { client, region }
}
}
#[async_trait]
impl CloudSearch for CloudSearchClient {
async fn build_suggesters(
&self,
input: BuildSuggestersRequest,
) -> Result<BuildSuggestersResponse, RusotoError<BuildSuggestersError>> {
let mut request = SignedRequest::new("POST", "cloudsearch", &self.region, "/");
let params = self.new_params("BuildSuggesters");
let mut params = params;
BuildSuggestersRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, BuildSuggestersError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result =
BuildSuggestersResponseDeserializer::deserialize("BuildSuggestersResult", stack)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn create_domain(
&self,
input: CreateDomainRequest,
) -> Result<CreateDomainResponse, RusotoError<CreateDomainError>> {
let mut request = SignedRequest::new("POST", "cloudsearch", &self.region, "/");
let params = self.new_params("CreateDomain");
let mut params = params;
CreateDomainRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, CreateDomainError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result =
CreateDomainResponseDeserializer::deserialize("CreateDomainResult", stack)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn define_analysis_scheme(
&self,
input: DefineAnalysisSchemeRequest,
) -> Result<DefineAnalysisSchemeResponse, RusotoError<DefineAnalysisSchemeError>> {
let mut request = SignedRequest::new("POST", "cloudsearch", &self.region, "/");
let params = self.new_params("DefineAnalysisScheme");
let mut params = params;
DefineAnalysisSchemeRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, DefineAnalysisSchemeError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result = DefineAnalysisSchemeResponseDeserializer::deserialize(
"DefineAnalysisSchemeResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn define_expression(
&self,
input: DefineExpressionRequest,
) -> Result<DefineExpressionResponse, RusotoError<DefineExpressionError>> {
let mut request = SignedRequest::new("POST", "cloudsearch", &self.region, "/");
let params = self.new_params("DefineExpression");
let mut params = params;
DefineExpressionRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, DefineExpressionError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result =
DefineExpressionResponseDeserializer::deserialize("DefineExpressionResult", stack)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn define_index_field(
&self,
input: DefineIndexFieldRequest,
) -> Result<DefineIndexFieldResponse, RusotoError<DefineIndexFieldError>> {
let mut request = SignedRequest::new("POST", "cloudsearch", &self.region, "/");
let params = self.new_params("DefineIndexField");
let mut params = params;
DefineIndexFieldRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, DefineIndexFieldError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result =
DefineIndexFieldResponseDeserializer::deserialize("DefineIndexFieldResult", stack)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn define_suggester(
&self,
input: DefineSuggesterRequest,
) -> Result<DefineSuggesterResponse, RusotoError<DefineSuggesterError>> {
let mut request = SignedRequest::new("POST", "cloudsearch", &self.region, "/");
let params = self.new_params("DefineSuggester");
let mut params = params;
DefineSuggesterRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, DefineSuggesterError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result =
DefineSuggesterResponseDeserializer::deserialize("DefineSuggesterResult", stack)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn delete_analysis_scheme(
&self,
input: DeleteAnalysisSchemeRequest,
) -> Result<DeleteAnalysisSchemeResponse, RusotoError<DeleteAnalysisSchemeError>> {
let mut request = SignedRequest::new("POST", "cloudsearch", &self.region, "/");
let params = self.new_params("DeleteAnalysisScheme");
let mut params = params;
DeleteAnalysisSchemeRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, DeleteAnalysisSchemeError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result = DeleteAnalysisSchemeResponseDeserializer::deserialize(
"DeleteAnalysisSchemeResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn delete_domain(
&self,
input: DeleteDomainRequest,
) -> Result<DeleteDomainResponse, RusotoError<DeleteDomainError>> {
let mut request = SignedRequest::new("POST", "cloudsearch", &self.region, "/");
let params = self.new_params("DeleteDomain");
let mut params = params;
DeleteDomainRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, DeleteDomainError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result =
DeleteDomainResponseDeserializer::deserialize("DeleteDomainResult", stack)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn delete_expression(
&self,
input: DeleteExpressionRequest,
) -> Result<DeleteExpressionResponse, RusotoError<DeleteExpressionError>> {
let mut request = SignedRequest::new("POST", "cloudsearch", &self.region, "/");
let params = self.new_params("DeleteExpression");
let mut params = params;
DeleteExpressionRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, DeleteExpressionError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result =
DeleteExpressionResponseDeserializer::deserialize("DeleteExpressionResult", stack)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn delete_index_field(
&self,
input: DeleteIndexFieldRequest,
) -> Result<DeleteIndexFieldResponse, RusotoError<DeleteIndexFieldError>> {
let mut request = SignedRequest::new("POST", "cloudsearch", &self.region, "/");
let params = self.new_params("DeleteIndexField");
let mut params = params;
DeleteIndexFieldRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, DeleteIndexFieldError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result =
DeleteIndexFieldResponseDeserializer::deserialize("DeleteIndexFieldResult", stack)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn delete_suggester(
&self,
input: DeleteSuggesterRequest,
) -> Result<DeleteSuggesterResponse, RusotoError<DeleteSuggesterError>> {
let mut request = SignedRequest::new("POST", "cloudsearch", &self.region, "/");
let params = self.new_params("DeleteSuggester");
let mut params = params;
DeleteSuggesterRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, DeleteSuggesterError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result =
DeleteSuggesterResponseDeserializer::deserialize("DeleteSuggesterResult", stack)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn describe_analysis_schemes(
&self,
input: DescribeAnalysisSchemesRequest,
) -> Result<DescribeAnalysisSchemesResponse, RusotoError<DescribeAnalysisSchemesError>> {
let mut request = SignedRequest::new("POST", "cloudsearch", &self.region, "/");
let params = self.new_params("DescribeAnalysisSchemes");
let mut params = params;
DescribeAnalysisSchemesRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, DescribeAnalysisSchemesError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result = DescribeAnalysisSchemesResponseDeserializer::deserialize(
"DescribeAnalysisSchemesResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn describe_availability_options(
&self,
input: DescribeAvailabilityOptionsRequest,
) -> Result<DescribeAvailabilityOptionsResponse, RusotoError<DescribeAvailabilityOptionsError>>
{
let mut request = SignedRequest::new("POST", "cloudsearch", &self.region, "/");
let params = self.new_params("DescribeAvailabilityOptions");
let mut params = params;
DescribeAvailabilityOptionsRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, DescribeAvailabilityOptionsError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result = DescribeAvailabilityOptionsResponseDeserializer::deserialize(
"DescribeAvailabilityOptionsResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn describe_domain_endpoint_options(
&self,
input: DescribeDomainEndpointOptionsRequest,
) -> Result<
DescribeDomainEndpointOptionsResponse,
RusotoError<DescribeDomainEndpointOptionsError>,
> {
let mut request = SignedRequest::new("POST", "cloudsearch", &self.region, "/");
let params = self.new_params("DescribeDomainEndpointOptions");
let mut params = params;
DescribeDomainEndpointOptionsRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, DescribeDomainEndpointOptionsError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result = DescribeDomainEndpointOptionsResponseDeserializer::deserialize(
"DescribeDomainEndpointOptionsResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn describe_domains(
&self,
input: DescribeDomainsRequest,
) -> Result<DescribeDomainsResponse, RusotoError<DescribeDomainsError>> {
let mut request = SignedRequest::new("POST", "cloudsearch", &self.region, "/");
let params = self.new_params("DescribeDomains");
let mut params = params;
DescribeDomainsRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, DescribeDomainsError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result =
DescribeDomainsResponseDeserializer::deserialize("DescribeDomainsResult", stack)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn describe_expressions(
&self,
input: DescribeExpressionsRequest,
) -> Result<DescribeExpressionsResponse, RusotoError<DescribeExpressionsError>> {
let mut request = SignedRequest::new("POST", "cloudsearch", &self.region, "/");
let params = self.new_params("DescribeExpressions");
let mut params = params;
DescribeExpressionsRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, DescribeExpressionsError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result = DescribeExpressionsResponseDeserializer::deserialize(
"DescribeExpressionsResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn describe_index_fields(
&self,
input: DescribeIndexFieldsRequest,
) -> Result<DescribeIndexFieldsResponse, RusotoError<DescribeIndexFieldsError>> {
let mut request = SignedRequest::new("POST", "cloudsearch", &self.region, "/");
let params = self.new_params("DescribeIndexFields");
let mut params = params;
DescribeIndexFieldsRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, DescribeIndexFieldsError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result = DescribeIndexFieldsResponseDeserializer::deserialize(
"DescribeIndexFieldsResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn describe_scaling_parameters(
&self,
input: DescribeScalingParametersRequest,
) -> Result<DescribeScalingParametersResponse, RusotoError<DescribeScalingParametersError>>
{
let mut request = SignedRequest::new("POST", "cloudsearch", &self.region, "/");
let params = self.new_params("DescribeScalingParameters");
let mut params = params;
DescribeScalingParametersRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, DescribeScalingParametersError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result = DescribeScalingParametersResponseDeserializer::deserialize(
"DescribeScalingParametersResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn describe_service_access_policies(
&self,
input: DescribeServiceAccessPoliciesRequest,
) -> Result<
DescribeServiceAccessPoliciesResponse,
RusotoError<DescribeServiceAccessPoliciesError>,
> {
let mut request = SignedRequest::new("POST", "cloudsearch", &self.region, "/");
let params = self.new_params("DescribeServiceAccessPolicies");
let mut params = params;
DescribeServiceAccessPoliciesRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, DescribeServiceAccessPoliciesError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result = DescribeServiceAccessPoliciesResponseDeserializer::deserialize(
"DescribeServiceAccessPoliciesResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn describe_suggesters(
&self,
input: DescribeSuggestersRequest,
) -> Result<DescribeSuggestersResponse, RusotoError<DescribeSuggestersError>> {
let mut request = SignedRequest::new("POST", "cloudsearch", &self.region, "/");
let params = self.new_params("DescribeSuggesters");
let mut params = params;
DescribeSuggestersRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, DescribeSuggestersError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result = DescribeSuggestersResponseDeserializer::deserialize(
"DescribeSuggestersResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn index_documents(
&self,
input: IndexDocumentsRequest,
) -> Result<IndexDocumentsResponse, RusotoError<IndexDocumentsError>> {
let mut request = SignedRequest::new("POST", "cloudsearch", &self.region, "/");
let params = self.new_params("IndexDocuments");
let mut params = params;
IndexDocumentsRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, IndexDocumentsError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result =
IndexDocumentsResponseDeserializer::deserialize("IndexDocumentsResult", stack)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn list_domain_names(
&self,
) -> Result<ListDomainNamesResponse, RusotoError<ListDomainNamesError>> {
let mut request = SignedRequest::new("POST", "cloudsearch", &self.region, "/");
let params = self.new_params("ListDomainNames");
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, ListDomainNamesError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result =
ListDomainNamesResponseDeserializer::deserialize("ListDomainNamesResult", stack)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn update_availability_options(
&self,
input: UpdateAvailabilityOptionsRequest,
) -> Result<UpdateAvailabilityOptionsResponse, RusotoError<UpdateAvailabilityOptionsError>>
{
let mut request = SignedRequest::new("POST", "cloudsearch", &self.region, "/");
let params = self.new_params("UpdateAvailabilityOptions");
let mut params = params;
UpdateAvailabilityOptionsRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, UpdateAvailabilityOptionsError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result = UpdateAvailabilityOptionsResponseDeserializer::deserialize(
"UpdateAvailabilityOptionsResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn update_domain_endpoint_options(
&self,
input: UpdateDomainEndpointOptionsRequest,
) -> Result<UpdateDomainEndpointOptionsResponse, RusotoError<UpdateDomainEndpointOptionsError>>
{
let mut request = SignedRequest::new("POST", "cloudsearch", &self.region, "/");
let params = self.new_params("UpdateDomainEndpointOptions");
let mut params = params;
UpdateDomainEndpointOptionsRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, UpdateDomainEndpointOptionsError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result = UpdateDomainEndpointOptionsResponseDeserializer::deserialize(
"UpdateDomainEndpointOptionsResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn update_scaling_parameters(
&self,
input: UpdateScalingParametersRequest,
) -> Result<UpdateScalingParametersResponse, RusotoError<UpdateScalingParametersError>> {
let mut request = SignedRequest::new("POST", "cloudsearch", &self.region, "/");
let params = self.new_params("UpdateScalingParameters");
let mut params = params;
UpdateScalingParametersRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, UpdateScalingParametersError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result = UpdateScalingParametersResponseDeserializer::deserialize(
"UpdateScalingParametersResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn update_service_access_policies(
&self,
input: UpdateServiceAccessPoliciesRequest,
) -> Result<UpdateServiceAccessPoliciesResponse, RusotoError<UpdateServiceAccessPoliciesError>>
{
let mut request = SignedRequest::new("POST", "cloudsearch", &self.region, "/");
let params = self.new_params("UpdateServiceAccessPolicies");
let mut params = params;
UpdateServiceAccessPoliciesRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, UpdateServiceAccessPoliciesError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result = UpdateServiceAccessPoliciesResponseDeserializer::deserialize(
"UpdateServiceAccessPoliciesResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
}