use std::error::Error;
use std::fmt;
use std::io;
#[allow(warnings)]
use futures::future;
use futures::Future;
use rusoto_core::region;
use rusoto_core::request::{BufferedHttpResponse, DispatchSignedRequest};
use rusoto_core::{Client, RusotoFuture};
use rusoto_core::credential::{CredentialsError, ProvideAwsCredentials};
use rusoto_core::request::HttpDispatchError;
use rusoto_core::param::{Params, ServiceParams};
use rusoto_core::signature::SignedRequest;
use rusoto_core::xmlerror::*;
use rusoto_core::xmlutil::{
characters, end_element, find_start_element, peek_at_name, skip_tree, start_element,
};
use rusoto_core::xmlutil::{Next, Peek, XmlParseError, XmlResponse};
use serde_urlencoded;
use std::str::FromStr;
use xml::reader::ParserConfig;
use xml::reader::XmlEvent;
use xml::EventReader;
enum DeserializerNext {
Close,
Skip,
Element(String),
}
struct APIVersionDeserializer;
impl APIVersionDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
try!(start_element(tag_name, stack));
let obj = try!(characters(stack));
try!(end_element(tag_name, stack));
Ok(obj)
}
}
struct ARNDeserializer;
impl ARNDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
try!(start_element(tag_name, stack));
let obj = try!(characters(stack));
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct AccessPoliciesStatus {
pub options: String,
pub status: OptionStatus,
}
struct AccessPoliciesStatusDeserializer;
impl AccessPoliciesStatusDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<AccessPoliciesStatus, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = AccessPoliciesStatus::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"Options" => {
obj.options =
try!(PolicyDocumentDeserializer::deserialize("Options", stack));
}
"Status" => {
obj.status = try!(OptionStatusDeserializer::deserialize("Status", stack));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
struct AlgorithmicStemmingDeserializer;
impl AlgorithmicStemmingDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
try!(start_element(tag_name, stack));
let obj = try!(characters(stack));
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
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>,
}
struct AnalysisOptionsDeserializer;
impl AnalysisOptionsDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<AnalysisOptions, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = AnalysisOptions::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"AlgorithmicStemming" => {
obj.algorithmic_stemming =
Some(try!(AlgorithmicStemmingDeserializer::deserialize(
"AlgorithmicStemming",
stack
)));
}
"JapaneseTokenizationDictionary" => {
obj.japanese_tokenization_dictionary =
Some(try!(StringDeserializer::deserialize(
"JapaneseTokenizationDictionary",
stack
)));
}
"StemmingDictionary" => {
obj.stemming_dictionary = Some(try!(StringDeserializer::deserialize(
"StemmingDictionary",
stack
)));
}
"Stopwords" => {
obj.stopwords =
Some(try!(StringDeserializer::deserialize("Stopwords", stack)));
}
"Synonyms" => {
obj.synonyms =
Some(try!(StringDeserializer::deserialize("Synonyms", stack)));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
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(Default, Debug, Clone, PartialEq)]
pub struct AnalysisScheme {
pub analysis_options: Option<AnalysisOptions>,
pub analysis_scheme_language: String,
pub analysis_scheme_name: String,
}
struct AnalysisSchemeDeserializer;
impl AnalysisSchemeDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<AnalysisScheme, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = AnalysisScheme::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"AnalysisOptions" => {
obj.analysis_options = Some(try!(
AnalysisOptionsDeserializer::deserialize("AnalysisOptions", stack)
));
}
"AnalysisSchemeLanguage" => {
obj.analysis_scheme_language =
try!(AnalysisSchemeLanguageDeserializer::deserialize(
"AnalysisSchemeLanguage",
stack
));
}
"AnalysisSchemeName" => {
obj.analysis_scheme_name = try!(StandardNameDeserializer::deserialize(
"AnalysisSchemeName",
stack
));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
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,
);
}
}
struct AnalysisSchemeLanguageDeserializer;
impl AnalysisSchemeLanguageDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
try!(start_element(tag_name, stack));
let obj = try!(characters(stack));
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct AnalysisSchemeStatus {
pub options: AnalysisScheme,
pub status: OptionStatus,
}
struct AnalysisSchemeStatusDeserializer;
impl AnalysisSchemeStatusDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<AnalysisSchemeStatus, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = AnalysisSchemeStatus::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"Options" => {
obj.options =
try!(AnalysisSchemeDeserializer::deserialize("Options", stack));
}
"Status" => {
obj.status = try!(OptionStatusDeserializer::deserialize("Status", stack));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
struct AnalysisSchemeStatusListDeserializer;
impl AnalysisSchemeStatusListDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<AnalysisSchemeStatus>, XmlParseError> {
let mut obj = vec![];
try!(start_element(tag_name, stack));
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "member" {
obj.push(try!(AnalysisSchemeStatusDeserializer::deserialize(
"member", stack
)));
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
try!(end_element(tag_name, stack));
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct AvailabilityOptionsStatus {
pub options: bool,
pub status: OptionStatus,
}
struct AvailabilityOptionsStatusDeserializer;
impl AvailabilityOptionsStatusDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<AvailabilityOptionsStatus, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = AvailabilityOptionsStatus::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"Options" => {
obj.options = try!(MultiAZDeserializer::deserialize("Options", stack));
}
"Status" => {
obj.status = try!(OptionStatusDeserializer::deserialize("Status", stack));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
struct BooleanDeserializer;
impl BooleanDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<bool, XmlParseError> {
try!(start_element(tag_name, stack));
let obj = bool::from_str(try!(characters(stack)).as_ref()).unwrap();
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
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(Default, Debug, Clone, PartialEq)]
pub struct BuildSuggestersResponse {
pub field_names: Option<Vec<String>>,
}
struct BuildSuggestersResponseDeserializer;
impl BuildSuggestersResponseDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<BuildSuggestersResponse, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = BuildSuggestersResponse::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"FieldNames" => {
obj.field_names = match obj.field_names {
Some(ref mut existing) => {
existing.extend(try!(FieldNameListDeserializer::deserialize(
"FieldNames",
stack
)));
Some(existing.to_vec())
}
None => Some(try!(FieldNameListDeserializer::deserialize(
"FieldNames",
stack
))),
};
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
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(Default, Debug, Clone, PartialEq)]
pub struct CreateDomainResponse {
pub domain_status: Option<DomainStatus>,
}
struct CreateDomainResponseDeserializer;
impl CreateDomainResponseDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CreateDomainResponse, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = CreateDomainResponse::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"DomainStatus" => {
obj.domain_status = Some(try!(DomainStatusDeserializer::deserialize(
"DomainStatus",
stack
)));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
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>,
}
struct DateArrayOptionsDeserializer;
impl DateArrayOptionsDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DateArrayOptions, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = DateArrayOptions::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"DefaultValue" => {
obj.default_value = Some(try!(FieldValueDeserializer::deserialize(
"DefaultValue",
stack
)));
}
"FacetEnabled" => {
obj.facet_enabled = Some(try!(BooleanDeserializer::deserialize(
"FacetEnabled",
stack
)));
}
"ReturnEnabled" => {
obj.return_enabled = Some(try!(BooleanDeserializer::deserialize(
"ReturnEnabled",
stack
)));
}
"SearchEnabled" => {
obj.search_enabled = Some(try!(BooleanDeserializer::deserialize(
"SearchEnabled",
stack
)));
}
"SourceFields" => {
obj.source_fields = Some(try!(
FieldNameCommaListDeserializer::deserialize("SourceFields", stack)
));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
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.to_string(),
);
}
if let Some(ref field_value) = obj.return_enabled {
params.put(
&format!("{}{}", prefix, "ReturnEnabled"),
&field_value.to_string(),
);
}
if let Some(ref field_value) = obj.search_enabled {
params.put(
&format!("{}{}", prefix, "SearchEnabled"),
&field_value.to_string(),
);
}
if let Some(ref field_value) = obj.source_fields {
params.put(&format!("{}{}", prefix, "SourceFields"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
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>,
}
struct DateOptionsDeserializer;
impl DateOptionsDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DateOptions, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = DateOptions::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"DefaultValue" => {
obj.default_value = Some(try!(FieldValueDeserializer::deserialize(
"DefaultValue",
stack
)));
}
"FacetEnabled" => {
obj.facet_enabled = Some(try!(BooleanDeserializer::deserialize(
"FacetEnabled",
stack
)));
}
"ReturnEnabled" => {
obj.return_enabled = Some(try!(BooleanDeserializer::deserialize(
"ReturnEnabled",
stack
)));
}
"SearchEnabled" => {
obj.search_enabled = Some(try!(BooleanDeserializer::deserialize(
"SearchEnabled",
stack
)));
}
"SortEnabled" => {
obj.sort_enabled =
Some(try!(BooleanDeserializer::deserialize("SortEnabled", stack)));
}
"SourceField" => {
obj.source_field = Some(try!(FieldNameDeserializer::deserialize(
"SourceField",
stack
)));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
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.to_string(),
);
}
if let Some(ref field_value) = obj.return_enabled {
params.put(
&format!("{}{}", prefix, "ReturnEnabled"),
&field_value.to_string(),
);
}
if let Some(ref field_value) = obj.search_enabled {
params.put(
&format!("{}{}", prefix, "SearchEnabled"),
&field_value.to_string(),
);
}
if let Some(ref field_value) = obj.sort_enabled {
params.put(
&format!("{}{}", prefix, "SortEnabled"),
&field_value.to_string(),
);
}
if let Some(ref field_value) = obj.source_field {
params.put(&format!("{}{}", prefix, "SourceField"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
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(Default, Debug, Clone, PartialEq)]
pub struct DefineAnalysisSchemeResponse {
pub analysis_scheme: AnalysisSchemeStatus,
}
struct DefineAnalysisSchemeResponseDeserializer;
impl DefineAnalysisSchemeResponseDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DefineAnalysisSchemeResponse, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = DefineAnalysisSchemeResponse::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"AnalysisScheme" => {
obj.analysis_scheme = try!(AnalysisSchemeStatusDeserializer::deserialize(
"AnalysisScheme",
stack
));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
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(Default, Debug, Clone, PartialEq)]
pub struct DefineExpressionResponse {
pub expression: ExpressionStatus,
}
struct DefineExpressionResponseDeserializer;
impl DefineExpressionResponseDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DefineExpressionResponse, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = DefineExpressionResponse::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"Expression" => {
obj.expression = try!(ExpressionStatusDeserializer::deserialize(
"Expression",
stack
));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
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(Default, Debug, Clone, PartialEq)]
pub struct DefineIndexFieldResponse {
pub index_field: IndexFieldStatus,
}
struct DefineIndexFieldResponseDeserializer;
impl DefineIndexFieldResponseDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DefineIndexFieldResponse, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = DefineIndexFieldResponse::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"IndexField" => {
obj.index_field = try!(IndexFieldStatusDeserializer::deserialize(
"IndexField",
stack
));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
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(Default, Debug, Clone, PartialEq)]
pub struct DefineSuggesterResponse {
pub suggester: SuggesterStatus,
}
struct DefineSuggesterResponseDeserializer;
impl DefineSuggesterResponseDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DefineSuggesterResponse, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = DefineSuggesterResponse::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"Suggester" => {
obj.suggester =
try!(SuggesterStatusDeserializer::deserialize("Suggester", stack));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
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(Default, Debug, Clone, PartialEq)]
pub struct DeleteAnalysisSchemeResponse {
pub analysis_scheme: AnalysisSchemeStatus,
}
struct DeleteAnalysisSchemeResponseDeserializer;
impl DeleteAnalysisSchemeResponseDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DeleteAnalysisSchemeResponse, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = DeleteAnalysisSchemeResponse::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"AnalysisScheme" => {
obj.analysis_scheme = try!(AnalysisSchemeStatusDeserializer::deserialize(
"AnalysisScheme",
stack
));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
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(Default, Debug, Clone, PartialEq)]
pub struct DeleteDomainResponse {
pub domain_status: Option<DomainStatus>,
}
struct DeleteDomainResponseDeserializer;
impl DeleteDomainResponseDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DeleteDomainResponse, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = DeleteDomainResponse::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"DomainStatus" => {
obj.domain_status = Some(try!(DomainStatusDeserializer::deserialize(
"DomainStatus",
stack
)));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
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(Default, Debug, Clone, PartialEq)]
pub struct DeleteExpressionResponse {
pub expression: ExpressionStatus,
}
struct DeleteExpressionResponseDeserializer;
impl DeleteExpressionResponseDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DeleteExpressionResponse, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = DeleteExpressionResponse::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"Expression" => {
obj.expression = try!(ExpressionStatusDeserializer::deserialize(
"Expression",
stack
));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
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(Default, Debug, Clone, PartialEq)]
pub struct DeleteIndexFieldResponse {
pub index_field: IndexFieldStatus,
}
struct DeleteIndexFieldResponseDeserializer;
impl DeleteIndexFieldResponseDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DeleteIndexFieldResponse, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = DeleteIndexFieldResponse::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"IndexField" => {
obj.index_field = try!(IndexFieldStatusDeserializer::deserialize(
"IndexField",
stack
));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
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(Default, Debug, Clone, PartialEq)]
pub struct DeleteSuggesterResponse {
pub suggester: SuggesterStatus,
}
struct DeleteSuggesterResponseDeserializer;
impl DeleteSuggesterResponseDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DeleteSuggesterResponse, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = DeleteSuggesterResponse::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"Suggester" => {
obj.suggester =
try!(SuggesterStatusDeserializer::deserialize("Suggester", stack));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
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.to_string(),
);
}
params.put(&format!("{}{}", prefix, "DomainName"), &obj.domain_name);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeAnalysisSchemesResponse {
pub analysis_schemes: Vec<AnalysisSchemeStatus>,
}
struct DescribeAnalysisSchemesResponseDeserializer;
impl DescribeAnalysisSchemesResponseDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeAnalysisSchemesResponse, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = DescribeAnalysisSchemesResponse::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"AnalysisSchemes" => {
obj.analysis_schemes.extend(try!(
AnalysisSchemeStatusListDeserializer::deserialize(
"AnalysisSchemes",
stack
)
));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
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.to_string(),
);
}
params.put(&format!("{}{}", prefix, "DomainName"), &obj.domain_name);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeAvailabilityOptionsResponse {
pub availability_options: Option<AvailabilityOptionsStatus>,
}
struct DescribeAvailabilityOptionsResponseDeserializer;
impl DescribeAvailabilityOptionsResponseDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeAvailabilityOptionsResponse, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = DescribeAvailabilityOptionsResponse::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"AvailabilityOptions" => {
obj.availability_options =
Some(try!(AvailabilityOptionsStatusDeserializer::deserialize(
"AvailabilityOptions",
stack
)));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
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(Default, Debug, Clone, PartialEq)]
pub struct DescribeDomainsResponse {
pub domain_status_list: Vec<DomainStatus>,
}
struct DescribeDomainsResponseDeserializer;
impl DescribeDomainsResponseDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeDomainsResponse, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = DescribeDomainsResponse::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"DomainStatusList" => {
obj.domain_status_list.extend(try!(
DomainStatusListDeserializer::deserialize("DomainStatusList", stack)
));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
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.to_string(),
);
}
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(Default, Debug, Clone, PartialEq)]
pub struct DescribeExpressionsResponse {
pub expressions: Vec<ExpressionStatus>,
}
struct DescribeExpressionsResponseDeserializer;
impl DescribeExpressionsResponseDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeExpressionsResponse, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = DescribeExpressionsResponse::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"Expressions" => {
obj.expressions.extend(try!(
ExpressionStatusListDeserializer::deserialize("Expressions", stack)
));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
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.to_string(),
);
}
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(Default, Debug, Clone, PartialEq)]
pub struct DescribeIndexFieldsResponse {
pub index_fields: Vec<IndexFieldStatus>,
}
struct DescribeIndexFieldsResponseDeserializer;
impl DescribeIndexFieldsResponseDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeIndexFieldsResponse, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = DescribeIndexFieldsResponse::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"IndexFields" => {
obj.index_fields.extend(try!(
IndexFieldStatusListDeserializer::deserialize("IndexFields", stack)
));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
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(Default, Debug, Clone, PartialEq)]
pub struct DescribeScalingParametersResponse {
pub scaling_parameters: ScalingParametersStatus,
}
struct DescribeScalingParametersResponseDeserializer;
impl DescribeScalingParametersResponseDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeScalingParametersResponse, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = DescribeScalingParametersResponse::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"ScalingParameters" => {
obj.scaling_parameters =
try!(ScalingParametersStatusDeserializer::deserialize(
"ScalingParameters",
stack
));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
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.to_string(),
);
}
params.put(&format!("{}{}", prefix, "DomainName"), &obj.domain_name);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeServiceAccessPoliciesResponse {
pub access_policies: AccessPoliciesStatus,
}
struct DescribeServiceAccessPoliciesResponseDeserializer;
impl DescribeServiceAccessPoliciesResponseDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeServiceAccessPoliciesResponse, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = DescribeServiceAccessPoliciesResponse::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"AccessPolicies" => {
obj.access_policies = try!(AccessPoliciesStatusDeserializer::deserialize(
"AccessPolicies",
stack
));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
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.to_string(),
);
}
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(Default, Debug, Clone, PartialEq)]
pub struct DescribeSuggestersResponse {
pub suggesters: Vec<SuggesterStatus>,
}
struct DescribeSuggestersResponseDeserializer;
impl DescribeSuggestersResponseDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeSuggestersResponse, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = DescribeSuggestersResponse::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
match &name[..] {
"Suggesters" => {
obj.suggesters.extend(try!(
SuggesterStatusListDeserializer::deserialize("Suggesters", stack)
));
}
_ => skip_tree(stack),
}
}
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DocumentSuggesterOptions {
pub fuzzy_matching: Option<String>,
pub sort_expression: Option<String>,
pub source_field: String,
}
struct DocumentSuggesterOptionsDeserializer;
impl DocumentSuggesterOptionsDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DocumentSuggesterOptions, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = DocumentSuggesterOptions::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"FuzzyMatching" => {
obj.fuzzy_matching = Some(try!(
SuggesterFuzzyMatchingDeserializer::deserialize("FuzzyMatching", stack)
));
}
"SortExpression" => {
obj.sort_expression = Some(try!(StringDeserializer::deserialize(
"SortExpression",
stack
)));
}
"SourceField" => {
obj.source_field =
try!(FieldNameDeserializer::deserialize("SourceField", stack));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
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);
}
}
struct DomainIdDeserializer;
impl DomainIdDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
try!(start_element(tag_name, stack));
let obj = try!(characters(stack));
try!(end_element(tag_name, stack));
Ok(obj)
}
}
struct DomainNameDeserializer;
impl DomainNameDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
try!(start_element(tag_name, stack));
let obj = try!(characters(stack));
try!(end_element(tag_name, stack));
Ok(obj)
}
}
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);
}
}
}
struct DomainNameMapDeserializer;
impl DomainNameMapDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<::std::collections::HashMap<String, String>, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = ::std::collections::HashMap::new();
while try!(peek_at_name(stack)) == "entry" {
try!(start_element("entry", stack));
let key = try!(DomainNameDeserializer::deserialize("key", stack));
let value = try!(APIVersionDeserializer::deserialize("value", stack));
obj.insert(key, value);
try!(end_element("entry", stack));
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
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>,
}
struct DomainStatusDeserializer;
impl DomainStatusDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DomainStatus, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = DomainStatus::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"ARN" => {
obj.arn = Some(try!(ARNDeserializer::deserialize("ARN", stack)));
}
"Created" => {
obj.created =
Some(try!(BooleanDeserializer::deserialize("Created", stack)));
}
"Deleted" => {
obj.deleted =
Some(try!(BooleanDeserializer::deserialize("Deleted", stack)));
}
"DocService" => {
obj.doc_service = Some(try!(ServiceEndpointDeserializer::deserialize(
"DocService",
stack
)));
}
"DomainId" => {
obj.domain_id = try!(DomainIdDeserializer::deserialize("DomainId", stack));
}
"DomainName" => {
obj.domain_name =
try!(DomainNameDeserializer::deserialize("DomainName", stack));
}
"Limits" => {
obj.limits = Some(try!(LimitsDeserializer::deserialize("Limits", stack)));
}
"Processing" => {
obj.processing =
Some(try!(BooleanDeserializer::deserialize("Processing", stack)));
}
"RequiresIndexDocuments" => {
obj.requires_index_documents = try!(BooleanDeserializer::deserialize(
"RequiresIndexDocuments",
stack
));
}
"SearchInstanceCount" => {
obj.search_instance_count = Some(try!(
InstanceCountDeserializer::deserialize("SearchInstanceCount", stack)
));
}
"SearchInstanceType" => {
obj.search_instance_type =
Some(try!(SearchInstanceTypeDeserializer::deserialize(
"SearchInstanceType",
stack
)));
}
"SearchPartitionCount" => {
obj.search_partition_count = Some(try!(
PartitionCountDeserializer::deserialize("SearchPartitionCount", stack)
));
}
"SearchService" => {
obj.search_service = Some(try!(ServiceEndpointDeserializer::deserialize(
"SearchService",
stack
)));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
struct DomainStatusListDeserializer;
impl DomainStatusListDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<DomainStatus>, XmlParseError> {
let mut obj = vec![];
try!(start_element(tag_name, stack));
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "member" {
obj.push(try!(DomainStatusDeserializer::deserialize("member", stack)));
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
try!(end_element(tag_name, stack));
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
struct DoubleDeserializer;
impl DoubleDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<f64, XmlParseError> {
try!(start_element(tag_name, stack));
let obj = f64::from_str(try!(characters(stack)).as_ref()).unwrap();
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
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>,
}
struct DoubleArrayOptionsDeserializer;
impl DoubleArrayOptionsDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DoubleArrayOptions, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = DoubleArrayOptions::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"DefaultValue" => {
obj.default_value =
Some(try!(DoubleDeserializer::deserialize("DefaultValue", stack)));
}
"FacetEnabled" => {
obj.facet_enabled = Some(try!(BooleanDeserializer::deserialize(
"FacetEnabled",
stack
)));
}
"ReturnEnabled" => {
obj.return_enabled = Some(try!(BooleanDeserializer::deserialize(
"ReturnEnabled",
stack
)));
}
"SearchEnabled" => {
obj.search_enabled = Some(try!(BooleanDeserializer::deserialize(
"SearchEnabled",
stack
)));
}
"SourceFields" => {
obj.source_fields = Some(try!(
FieldNameCommaListDeserializer::deserialize("SourceFields", stack)
));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
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.to_string(),
);
}
if let Some(ref field_value) = obj.facet_enabled {
params.put(
&format!("{}{}", prefix, "FacetEnabled"),
&field_value.to_string(),
);
}
if let Some(ref field_value) = obj.return_enabled {
params.put(
&format!("{}{}", prefix, "ReturnEnabled"),
&field_value.to_string(),
);
}
if let Some(ref field_value) = obj.search_enabled {
params.put(
&format!("{}{}", prefix, "SearchEnabled"),
&field_value.to_string(),
);
}
if let Some(ref field_value) = obj.source_fields {
params.put(&format!("{}{}", prefix, "SourceFields"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
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>,
}
struct DoubleOptionsDeserializer;
impl DoubleOptionsDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DoubleOptions, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = DoubleOptions::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"DefaultValue" => {
obj.default_value =
Some(try!(DoubleDeserializer::deserialize("DefaultValue", stack)));
}
"FacetEnabled" => {
obj.facet_enabled = Some(try!(BooleanDeserializer::deserialize(
"FacetEnabled",
stack
)));
}
"ReturnEnabled" => {
obj.return_enabled = Some(try!(BooleanDeserializer::deserialize(
"ReturnEnabled",
stack
)));
}
"SearchEnabled" => {
obj.search_enabled = Some(try!(BooleanDeserializer::deserialize(
"SearchEnabled",
stack
)));
}
"SortEnabled" => {
obj.sort_enabled =
Some(try!(BooleanDeserializer::deserialize("SortEnabled", stack)));
}
"SourceField" => {
obj.source_field = Some(try!(FieldNameDeserializer::deserialize(
"SourceField",
stack
)));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
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.to_string(),
);
}
if let Some(ref field_value) = obj.facet_enabled {
params.put(
&format!("{}{}", prefix, "FacetEnabled"),
&field_value.to_string(),
);
}
if let Some(ref field_value) = obj.return_enabled {
params.put(
&format!("{}{}", prefix, "ReturnEnabled"),
&field_value.to_string(),
);
}
if let Some(ref field_value) = obj.search_enabled {
params.put(
&format!("{}{}", prefix, "SearchEnabled"),
&field_value.to_string(),
);
}
if let Some(ref field_value) = obj.sort_enabled {
params.put(
&format!("{}{}", prefix, "SortEnabled"),
&field_value.to_string(),
);
}
if let Some(ref field_value) = obj.source_field {
params.put(&format!("{}{}", prefix, "SourceField"), &field_value);
}
}
}
struct DynamicFieldNameDeserializer;
impl DynamicFieldNameDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
try!(start_element(tag_name, stack));
let obj = try!(characters(stack));
try!(end_element(tag_name, stack));
Ok(obj)
}
}
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(Default, Debug, Clone, PartialEq)]
pub struct Expression {
pub expression_name: String,
pub expression_value: String,
}
struct ExpressionDeserializer;
impl ExpressionDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Expression, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = Expression::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"ExpressionName" => {
obj.expression_name = try!(StandardNameDeserializer::deserialize(
"ExpressionName",
stack
));
}
"ExpressionValue" => {
obj.expression_value = try!(ExpressionValueDeserializer::deserialize(
"ExpressionValue",
stack
));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
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(Default, Debug, Clone, PartialEq)]
pub struct ExpressionStatus {
pub options: Expression,
pub status: OptionStatus,
}
struct ExpressionStatusDeserializer;
impl ExpressionStatusDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ExpressionStatus, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = ExpressionStatus::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"Options" => {
obj.options = try!(ExpressionDeserializer::deserialize("Options", stack));
}
"Status" => {
obj.status = try!(OptionStatusDeserializer::deserialize("Status", stack));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
struct ExpressionStatusListDeserializer;
impl ExpressionStatusListDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<ExpressionStatus>, XmlParseError> {
let mut obj = vec![];
try!(start_element(tag_name, stack));
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "member" {
obj.push(try!(ExpressionStatusDeserializer::deserialize(
"member", stack
)));
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
try!(end_element(tag_name, stack));
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
struct ExpressionValueDeserializer;
impl ExpressionValueDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
try!(start_element(tag_name, stack));
let obj = try!(characters(stack));
try!(end_element(tag_name, stack));
Ok(obj)
}
}
struct FieldNameDeserializer;
impl FieldNameDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
try!(start_element(tag_name, stack));
let obj = try!(characters(stack));
try!(end_element(tag_name, stack));
Ok(obj)
}
}
struct FieldNameCommaListDeserializer;
impl FieldNameCommaListDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
try!(start_element(tag_name, stack));
let obj = try!(characters(stack));
try!(end_element(tag_name, stack));
Ok(obj)
}
}
struct FieldNameListDeserializer;
impl FieldNameListDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<String>, XmlParseError> {
let mut obj = vec![];
try!(start_element(tag_name, stack));
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "member" {
obj.push(try!(FieldNameDeserializer::deserialize("member", stack)));
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
try!(end_element(tag_name, stack));
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
struct FieldValueDeserializer;
impl FieldValueDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
try!(start_element(tag_name, stack));
let obj = try!(characters(stack));
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
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(Default, Debug, Clone, PartialEq)]
pub struct IndexDocumentsResponse {
pub field_names: Option<Vec<String>>,
}
struct IndexDocumentsResponseDeserializer;
impl IndexDocumentsResponseDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<IndexDocumentsResponse, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = IndexDocumentsResponse::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"FieldNames" => {
obj.field_names = match obj.field_names {
Some(ref mut existing) => {
existing.extend(try!(FieldNameListDeserializer::deserialize(
"FieldNames",
stack
)));
Some(existing.to_vec())
}
None => Some(try!(FieldNameListDeserializer::deserialize(
"FieldNames",
stack
))),
};
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
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>,
}
struct IndexFieldDeserializer;
impl IndexFieldDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<IndexField, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = IndexField::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"DateArrayOptions" => {
obj.date_array_options = Some(try!(
DateArrayOptionsDeserializer::deserialize("DateArrayOptions", stack)
));
}
"DateOptions" => {
obj.date_options = Some(try!(DateOptionsDeserializer::deserialize(
"DateOptions",
stack
)));
}
"DoubleArrayOptions" => {
obj.double_array_options =
Some(try!(DoubleArrayOptionsDeserializer::deserialize(
"DoubleArrayOptions",
stack
)));
}
"DoubleOptions" => {
obj.double_options = Some(try!(DoubleOptionsDeserializer::deserialize(
"DoubleOptions",
stack
)));
}
"IndexFieldName" => {
obj.index_field_name = try!(DynamicFieldNameDeserializer::deserialize(
"IndexFieldName",
stack
));
}
"IndexFieldType" => {
obj.index_field_type = try!(IndexFieldTypeDeserializer::deserialize(
"IndexFieldType",
stack
));
}
"IntArrayOptions" => {
obj.int_array_options = Some(try!(
IntArrayOptionsDeserializer::deserialize("IntArrayOptions", stack)
));
}
"IntOptions" => {
obj.int_options = Some(try!(IntOptionsDeserializer::deserialize(
"IntOptions",
stack
)));
}
"LatLonOptions" => {
obj.lat_lon_options = Some(try!(LatLonOptionsDeserializer::deserialize(
"LatLonOptions",
stack
)));
}
"LiteralArrayOptions" => {
obj.literal_array_options =
Some(try!(LiteralArrayOptionsDeserializer::deserialize(
"LiteralArrayOptions",
stack
)));
}
"LiteralOptions" => {
obj.literal_options = Some(try!(LiteralOptionsDeserializer::deserialize(
"LiteralOptions",
stack
)));
}
"TextArrayOptions" => {
obj.text_array_options = Some(try!(
TextArrayOptionsDeserializer::deserialize("TextArrayOptions", stack)
));
}
"TextOptions" => {
obj.text_options = Some(try!(TextOptionsDeserializer::deserialize(
"TextOptions",
stack
)));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
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(Default, Debug, Clone, PartialEq)]
pub struct IndexFieldStatus {
pub options: IndexField,
pub status: OptionStatus,
}
struct IndexFieldStatusDeserializer;
impl IndexFieldStatusDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<IndexFieldStatus, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = IndexFieldStatus::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"Options" => {
obj.options = try!(IndexFieldDeserializer::deserialize("Options", stack));
}
"Status" => {
obj.status = try!(OptionStatusDeserializer::deserialize("Status", stack));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
struct IndexFieldStatusListDeserializer;
impl IndexFieldStatusListDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<IndexFieldStatus>, XmlParseError> {
let mut obj = vec![];
try!(start_element(tag_name, stack));
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "member" {
obj.push(try!(IndexFieldStatusDeserializer::deserialize(
"member", stack
)));
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
try!(end_element(tag_name, stack));
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
struct IndexFieldTypeDeserializer;
impl IndexFieldTypeDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
try!(start_element(tag_name, stack));
let obj = try!(characters(stack));
try!(end_element(tag_name, stack));
Ok(obj)
}
}
struct InstanceCountDeserializer;
impl InstanceCountDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<i64, XmlParseError> {
try!(start_element(tag_name, stack));
let obj = i64::from_str(try!(characters(stack)).as_ref()).unwrap();
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
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>,
}
struct IntArrayOptionsDeserializer;
impl IntArrayOptionsDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<IntArrayOptions, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = IntArrayOptions::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"DefaultValue" => {
obj.default_value =
Some(try!(LongDeserializer::deserialize("DefaultValue", stack)));
}
"FacetEnabled" => {
obj.facet_enabled = Some(try!(BooleanDeserializer::deserialize(
"FacetEnabled",
stack
)));
}
"ReturnEnabled" => {
obj.return_enabled = Some(try!(BooleanDeserializer::deserialize(
"ReturnEnabled",
stack
)));
}
"SearchEnabled" => {
obj.search_enabled = Some(try!(BooleanDeserializer::deserialize(
"SearchEnabled",
stack
)));
}
"SourceFields" => {
obj.source_fields = Some(try!(
FieldNameCommaListDeserializer::deserialize("SourceFields", stack)
));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
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.to_string(),
);
}
if let Some(ref field_value) = obj.facet_enabled {
params.put(
&format!("{}{}", prefix, "FacetEnabled"),
&field_value.to_string(),
);
}
if let Some(ref field_value) = obj.return_enabled {
params.put(
&format!("{}{}", prefix, "ReturnEnabled"),
&field_value.to_string(),
);
}
if let Some(ref field_value) = obj.search_enabled {
params.put(
&format!("{}{}", prefix, "SearchEnabled"),
&field_value.to_string(),
);
}
if let Some(ref field_value) = obj.source_fields {
params.put(&format!("{}{}", prefix, "SourceFields"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
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>,
}
struct IntOptionsDeserializer;
impl IntOptionsDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<IntOptions, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = IntOptions::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"DefaultValue" => {
obj.default_value =
Some(try!(LongDeserializer::deserialize("DefaultValue", stack)));
}
"FacetEnabled" => {
obj.facet_enabled = Some(try!(BooleanDeserializer::deserialize(
"FacetEnabled",
stack
)));
}
"ReturnEnabled" => {
obj.return_enabled = Some(try!(BooleanDeserializer::deserialize(
"ReturnEnabled",
stack
)));
}
"SearchEnabled" => {
obj.search_enabled = Some(try!(BooleanDeserializer::deserialize(
"SearchEnabled",
stack
)));
}
"SortEnabled" => {
obj.sort_enabled =
Some(try!(BooleanDeserializer::deserialize("SortEnabled", stack)));
}
"SourceField" => {
obj.source_field = Some(try!(FieldNameDeserializer::deserialize(
"SourceField",
stack
)));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
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.to_string(),
);
}
if let Some(ref field_value) = obj.facet_enabled {
params.put(
&format!("{}{}", prefix, "FacetEnabled"),
&field_value.to_string(),
);
}
if let Some(ref field_value) = obj.return_enabled {
params.put(
&format!("{}{}", prefix, "ReturnEnabled"),
&field_value.to_string(),
);
}
if let Some(ref field_value) = obj.search_enabled {
params.put(
&format!("{}{}", prefix, "SearchEnabled"),
&field_value.to_string(),
);
}
if let Some(ref field_value) = obj.sort_enabled {
params.put(
&format!("{}{}", prefix, "SortEnabled"),
&field_value.to_string(),
);
}
if let Some(ref field_value) = obj.source_field {
params.put(&format!("{}{}", prefix, "SourceField"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
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>,
}
struct LatLonOptionsDeserializer;
impl LatLonOptionsDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<LatLonOptions, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = LatLonOptions::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"DefaultValue" => {
obj.default_value = Some(try!(FieldValueDeserializer::deserialize(
"DefaultValue",
stack
)));
}
"FacetEnabled" => {
obj.facet_enabled = Some(try!(BooleanDeserializer::deserialize(
"FacetEnabled",
stack
)));
}
"ReturnEnabled" => {
obj.return_enabled = Some(try!(BooleanDeserializer::deserialize(
"ReturnEnabled",
stack
)));
}
"SearchEnabled" => {
obj.search_enabled = Some(try!(BooleanDeserializer::deserialize(
"SearchEnabled",
stack
)));
}
"SortEnabled" => {
obj.sort_enabled =
Some(try!(BooleanDeserializer::deserialize("SortEnabled", stack)));
}
"SourceField" => {
obj.source_field = Some(try!(FieldNameDeserializer::deserialize(
"SourceField",
stack
)));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
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.to_string(),
);
}
if let Some(ref field_value) = obj.return_enabled {
params.put(
&format!("{}{}", prefix, "ReturnEnabled"),
&field_value.to_string(),
);
}
if let Some(ref field_value) = obj.search_enabled {
params.put(
&format!("{}{}", prefix, "SearchEnabled"),
&field_value.to_string(),
);
}
if let Some(ref field_value) = obj.sort_enabled {
params.put(
&format!("{}{}", prefix, "SortEnabled"),
&field_value.to_string(),
);
}
if let Some(ref field_value) = obj.source_field {
params.put(&format!("{}{}", prefix, "SourceField"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct Limits {
pub maximum_partition_count: i64,
pub maximum_replication_count: i64,
}
struct LimitsDeserializer;
impl LimitsDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Limits, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = Limits::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"MaximumPartitionCount" => {
obj.maximum_partition_count =
try!(MaximumPartitionCountDeserializer::deserialize(
"MaximumPartitionCount",
stack
));
}
"MaximumReplicationCount" => {
obj.maximum_replication_count =
try!(MaximumReplicationCountDeserializer::deserialize(
"MaximumReplicationCount",
stack
));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ListDomainNamesResponse {
pub domain_names: Option<::std::collections::HashMap<String, String>>,
}
struct ListDomainNamesResponseDeserializer;
impl ListDomainNamesResponseDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ListDomainNamesResponse, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = ListDomainNamesResponse::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"DomainNames" => {
obj.domain_names = Some(try!(DomainNameMapDeserializer::deserialize(
"DomainNames",
stack
)));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
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>,
}
struct LiteralArrayOptionsDeserializer;
impl LiteralArrayOptionsDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<LiteralArrayOptions, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = LiteralArrayOptions::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"DefaultValue" => {
obj.default_value = Some(try!(FieldValueDeserializer::deserialize(
"DefaultValue",
stack
)));
}
"FacetEnabled" => {
obj.facet_enabled = Some(try!(BooleanDeserializer::deserialize(
"FacetEnabled",
stack
)));
}
"ReturnEnabled" => {
obj.return_enabled = Some(try!(BooleanDeserializer::deserialize(
"ReturnEnabled",
stack
)));
}
"SearchEnabled" => {
obj.search_enabled = Some(try!(BooleanDeserializer::deserialize(
"SearchEnabled",
stack
)));
}
"SourceFields" => {
obj.source_fields = Some(try!(
FieldNameCommaListDeserializer::deserialize("SourceFields", stack)
));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
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.to_string(),
);
}
if let Some(ref field_value) = obj.return_enabled {
params.put(
&format!("{}{}", prefix, "ReturnEnabled"),
&field_value.to_string(),
);
}
if let Some(ref field_value) = obj.search_enabled {
params.put(
&format!("{}{}", prefix, "SearchEnabled"),
&field_value.to_string(),
);
}
if let Some(ref field_value) = obj.source_fields {
params.put(&format!("{}{}", prefix, "SourceFields"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
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>,
}
struct LiteralOptionsDeserializer;
impl LiteralOptionsDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<LiteralOptions, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = LiteralOptions::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"DefaultValue" => {
obj.default_value = Some(try!(FieldValueDeserializer::deserialize(
"DefaultValue",
stack
)));
}
"FacetEnabled" => {
obj.facet_enabled = Some(try!(BooleanDeserializer::deserialize(
"FacetEnabled",
stack
)));
}
"ReturnEnabled" => {
obj.return_enabled = Some(try!(BooleanDeserializer::deserialize(
"ReturnEnabled",
stack
)));
}
"SearchEnabled" => {
obj.search_enabled = Some(try!(BooleanDeserializer::deserialize(
"SearchEnabled",
stack
)));
}
"SortEnabled" => {
obj.sort_enabled =
Some(try!(BooleanDeserializer::deserialize("SortEnabled", stack)));
}
"SourceField" => {
obj.source_field = Some(try!(FieldNameDeserializer::deserialize(
"SourceField",
stack
)));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
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.to_string(),
);
}
if let Some(ref field_value) = obj.return_enabled {
params.put(
&format!("{}{}", prefix, "ReturnEnabled"),
&field_value.to_string(),
);
}
if let Some(ref field_value) = obj.search_enabled {
params.put(
&format!("{}{}", prefix, "SearchEnabled"),
&field_value.to_string(),
);
}
if let Some(ref field_value) = obj.sort_enabled {
params.put(
&format!("{}{}", prefix, "SortEnabled"),
&field_value.to_string(),
);
}
if let Some(ref field_value) = obj.source_field {
params.put(&format!("{}{}", prefix, "SourceField"), &field_value);
}
}
}
struct LongDeserializer;
impl LongDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<i64, XmlParseError> {
try!(start_element(tag_name, stack));
let obj = i64::from_str(try!(characters(stack)).as_ref()).unwrap();
try!(end_element(tag_name, stack));
Ok(obj)
}
}
struct MaximumPartitionCountDeserializer;
impl MaximumPartitionCountDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<i64, XmlParseError> {
try!(start_element(tag_name, stack));
let obj = i64::from_str(try!(characters(stack)).as_ref()).unwrap();
try!(end_element(tag_name, stack));
Ok(obj)
}
}
struct MaximumReplicationCountDeserializer;
impl MaximumReplicationCountDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<i64, XmlParseError> {
try!(start_element(tag_name, stack));
let obj = i64::from_str(try!(characters(stack)).as_ref()).unwrap();
try!(end_element(tag_name, stack));
Ok(obj)
}
}
struct MultiAZDeserializer;
impl MultiAZDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<bool, XmlParseError> {
try!(start_element(tag_name, stack));
let obj = bool::from_str(try!(characters(stack)).as_ref()).unwrap();
try!(end_element(tag_name, stack));
Ok(obj)
}
}
struct OptionStateDeserializer;
impl OptionStateDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
try!(start_element(tag_name, stack));
let obj = try!(characters(stack));
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct OptionStatus {
pub creation_date: String,
pub pending_deletion: Option<bool>,
pub state: String,
pub update_date: String,
pub update_version: Option<i64>,
}
struct OptionStatusDeserializer;
impl OptionStatusDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<OptionStatus, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = OptionStatus::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"CreationDate" => {
obj.creation_date = try!(UpdateTimestampDeserializer::deserialize(
"CreationDate",
stack
));
}
"PendingDeletion" => {
obj.pending_deletion = Some(try!(BooleanDeserializer::deserialize(
"PendingDeletion",
stack
)));
}
"State" => {
obj.state = try!(OptionStateDeserializer::deserialize("State", stack));
}
"UpdateDate" => {
obj.update_date = try!(UpdateTimestampDeserializer::deserialize(
"UpdateDate",
stack
));
}
"UpdateVersion" => {
obj.update_version = Some(try!(UIntValueDeserializer::deserialize(
"UpdateVersion",
stack
)));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
struct PartitionCountDeserializer;
impl PartitionCountDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<i64, XmlParseError> {
try!(start_element(tag_name, stack));
let obj = i64::from_str(try!(characters(stack)).as_ref()).unwrap();
try!(end_element(tag_name, stack));
Ok(obj)
}
}
struct PartitionInstanceTypeDeserializer;
impl PartitionInstanceTypeDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
try!(start_element(tag_name, stack));
let obj = try!(characters(stack));
try!(end_element(tag_name, stack));
Ok(obj)
}
}
struct PolicyDocumentDeserializer;
impl PolicyDocumentDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
try!(start_element(tag_name, stack));
let obj = try!(characters(stack));
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ScalingParameters {
pub desired_instance_type: Option<String>,
pub desired_partition_count: Option<i64>,
pub desired_replication_count: Option<i64>,
}
struct ScalingParametersDeserializer;
impl ScalingParametersDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ScalingParameters, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = ScalingParameters::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"DesiredInstanceType" => {
obj.desired_instance_type =
Some(try!(PartitionInstanceTypeDeserializer::deserialize(
"DesiredInstanceType",
stack
)));
}
"DesiredPartitionCount" => {
obj.desired_partition_count = Some(try!(
UIntValueDeserializer::deserialize("DesiredPartitionCount", stack)
));
}
"DesiredReplicationCount" => {
obj.desired_replication_count = Some(try!(
UIntValueDeserializer::deserialize("DesiredReplicationCount", stack)
));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
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.to_string(),
);
}
if let Some(ref field_value) = obj.desired_replication_count {
params.put(
&format!("{}{}", prefix, "DesiredReplicationCount"),
&field_value.to_string(),
);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ScalingParametersStatus {
pub options: ScalingParameters,
pub status: OptionStatus,
}
struct ScalingParametersStatusDeserializer;
impl ScalingParametersStatusDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ScalingParametersStatus, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = ScalingParametersStatus::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"Options" => {
obj.options =
try!(ScalingParametersDeserializer::deserialize("Options", stack));
}
"Status" => {
obj.status = try!(OptionStatusDeserializer::deserialize("Status", stack));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
struct SearchInstanceTypeDeserializer;
impl SearchInstanceTypeDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
try!(start_element(tag_name, stack));
let obj = try!(characters(stack));
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ServiceEndpoint {
pub endpoint: Option<String>,
}
struct ServiceEndpointDeserializer;
impl ServiceEndpointDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ServiceEndpoint, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = ServiceEndpoint::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"Endpoint" => {
obj.endpoint =
Some(try!(ServiceUrlDeserializer::deserialize("Endpoint", stack)));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
struct ServiceUrlDeserializer;
impl ServiceUrlDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
try!(start_element(tag_name, stack));
let obj = try!(characters(stack));
try!(end_element(tag_name, stack));
Ok(obj)
}
}
struct StandardNameDeserializer;
impl StandardNameDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
try!(start_element(tag_name, stack));
let obj = try!(characters(stack));
try!(end_element(tag_name, stack));
Ok(obj)
}
}
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);
}
}
}
struct StringDeserializer;
impl StringDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
try!(start_element(tag_name, stack));
let obj = try!(characters(stack));
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct Suggester {
pub document_suggester_options: DocumentSuggesterOptions,
pub suggester_name: String,
}
struct SuggesterDeserializer;
impl SuggesterDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Suggester, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = Suggester::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"DocumentSuggesterOptions" => {
obj.document_suggester_options =
try!(DocumentSuggesterOptionsDeserializer::deserialize(
"DocumentSuggesterOptions",
stack
));
}
"SuggesterName" => {
obj.suggester_name = try!(StandardNameDeserializer::deserialize(
"SuggesterName",
stack
));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
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,
);
}
}
struct SuggesterFuzzyMatchingDeserializer;
impl SuggesterFuzzyMatchingDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
try!(start_element(tag_name, stack));
let obj = try!(characters(stack));
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct SuggesterStatus {
pub options: Suggester,
pub status: OptionStatus,
}
struct SuggesterStatusDeserializer;
impl SuggesterStatusDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<SuggesterStatus, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = SuggesterStatus::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"Options" => {
obj.options = try!(SuggesterDeserializer::deserialize("Options", stack));
}
"Status" => {
obj.status = try!(OptionStatusDeserializer::deserialize("Status", stack));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
struct SuggesterStatusListDeserializer;
impl SuggesterStatusListDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<SuggesterStatus>, XmlParseError> {
let mut obj = vec![];
try!(start_element(tag_name, stack));
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "member" {
obj.push(try!(SuggesterStatusDeserializer::deserialize(
"member", stack
)));
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
try!(end_element(tag_name, stack));
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
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>,
}
struct TextArrayOptionsDeserializer;
impl TextArrayOptionsDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<TextArrayOptions, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = TextArrayOptions::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"AnalysisScheme" => {
obj.analysis_scheme =
Some(try!(WordDeserializer::deserialize("AnalysisScheme", stack)));
}
"DefaultValue" => {
obj.default_value = Some(try!(FieldValueDeserializer::deserialize(
"DefaultValue",
stack
)));
}
"HighlightEnabled" => {
obj.highlight_enabled = Some(try!(BooleanDeserializer::deserialize(
"HighlightEnabled",
stack
)));
}
"ReturnEnabled" => {
obj.return_enabled = Some(try!(BooleanDeserializer::deserialize(
"ReturnEnabled",
stack
)));
}
"SourceFields" => {
obj.source_fields = Some(try!(
FieldNameCommaListDeserializer::deserialize("SourceFields", stack)
));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
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.to_string(),
);
}
if let Some(ref field_value) = obj.return_enabled {
params.put(
&format!("{}{}", prefix, "ReturnEnabled"),
&field_value.to_string(),
);
}
if let Some(ref field_value) = obj.source_fields {
params.put(&format!("{}{}", prefix, "SourceFields"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
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>,
}
struct TextOptionsDeserializer;
impl TextOptionsDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<TextOptions, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = TextOptions::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"AnalysisScheme" => {
obj.analysis_scheme =
Some(try!(WordDeserializer::deserialize("AnalysisScheme", stack)));
}
"DefaultValue" => {
obj.default_value = Some(try!(FieldValueDeserializer::deserialize(
"DefaultValue",
stack
)));
}
"HighlightEnabled" => {
obj.highlight_enabled = Some(try!(BooleanDeserializer::deserialize(
"HighlightEnabled",
stack
)));
}
"ReturnEnabled" => {
obj.return_enabled = Some(try!(BooleanDeserializer::deserialize(
"ReturnEnabled",
stack
)));
}
"SortEnabled" => {
obj.sort_enabled =
Some(try!(BooleanDeserializer::deserialize("SortEnabled", stack)));
}
"SourceField" => {
obj.source_field = Some(try!(FieldNameDeserializer::deserialize(
"SourceField",
stack
)));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
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.to_string(),
);
}
if let Some(ref field_value) = obj.return_enabled {
params.put(
&format!("{}{}", prefix, "ReturnEnabled"),
&field_value.to_string(),
);
}
if let Some(ref field_value) = obj.sort_enabled {
params.put(
&format!("{}{}", prefix, "SortEnabled"),
&field_value.to_string(),
);
}
if let Some(ref field_value) = obj.source_field {
params.put(&format!("{}{}", prefix, "SourceField"), &field_value);
}
}
}
struct UIntValueDeserializer;
impl UIntValueDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<i64, XmlParseError> {
try!(start_element(tag_name, stack));
let obj = i64::from_str(try!(characters(stack)).as_ref()).unwrap();
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
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.to_string(),
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct UpdateAvailabilityOptionsResponse {
pub availability_options: Option<AvailabilityOptionsStatus>,
}
struct UpdateAvailabilityOptionsResponseDeserializer;
impl UpdateAvailabilityOptionsResponseDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<UpdateAvailabilityOptionsResponse, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = UpdateAvailabilityOptionsResponse::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"AvailabilityOptions" => {
obj.availability_options =
Some(try!(AvailabilityOptionsStatusDeserializer::deserialize(
"AvailabilityOptions",
stack
)));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
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(Default, Debug, Clone, PartialEq)]
pub struct UpdateScalingParametersResponse {
pub scaling_parameters: ScalingParametersStatus,
}
struct UpdateScalingParametersResponseDeserializer;
impl UpdateScalingParametersResponseDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<UpdateScalingParametersResponse, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = UpdateScalingParametersResponse::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"ScalingParameters" => {
obj.scaling_parameters =
try!(ScalingParametersStatusDeserializer::deserialize(
"ScalingParameters",
stack
));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
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(Default, Debug, Clone, PartialEq)]
pub struct UpdateServiceAccessPoliciesResponse {
pub access_policies: AccessPoliciesStatus,
}
struct UpdateServiceAccessPoliciesResponseDeserializer;
impl UpdateServiceAccessPoliciesResponseDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<UpdateServiceAccessPoliciesResponse, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = UpdateServiceAccessPoliciesResponse::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"AccessPolicies" => {
obj.access_policies = try!(AccessPoliciesStatusDeserializer::deserialize(
"AccessPolicies",
stack
));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
struct UpdateTimestampDeserializer;
impl UpdateTimestampDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
try!(start_element(tag_name, stack));
let obj = try!(characters(stack));
try!(end_element(tag_name, stack));
Ok(obj)
}
}
struct WordDeserializer;
impl WordDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
try!(start_element(tag_name, stack));
let obj = try!(characters(stack));
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Debug, PartialEq)]
pub enum BuildSuggestersError {
Base(String),
Internal(String),
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl BuildSuggestersError {
pub fn from_response(res: BufferedHttpResponse) -> BuildSuggestersError {
{
let reader = EventReader::new(res.body.as_slice());
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 BuildSuggestersError::Base(String::from(parsed_error.message))
}
"InternalException" => {
return BuildSuggestersError::Internal(String::from(parsed_error.message))
}
"ResourceNotFound" => {
return BuildSuggestersError::ResourceNotFound(String::from(
parsed_error.message,
))
}
_ => {}
}
}
}
BuildSuggestersError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for BuildSuggestersError {
fn from(err: XmlParseError) -> BuildSuggestersError {
let XmlParseError(message) = err;
BuildSuggestersError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for BuildSuggestersError {
fn from(err: CredentialsError) -> BuildSuggestersError {
BuildSuggestersError::Credentials(err)
}
}
impl From<HttpDispatchError> for BuildSuggestersError {
fn from(err: HttpDispatchError) -> BuildSuggestersError {
BuildSuggestersError::HttpDispatch(err)
}
}
impl From<io::Error> for BuildSuggestersError {
fn from(err: io::Error) -> BuildSuggestersError {
BuildSuggestersError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for BuildSuggestersError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for BuildSuggestersError {
fn description(&self) -> &str {
match *self {
BuildSuggestersError::Base(ref cause) => cause,
BuildSuggestersError::Internal(ref cause) => cause,
BuildSuggestersError::ResourceNotFound(ref cause) => cause,
BuildSuggestersError::Validation(ref cause) => cause,
BuildSuggestersError::Credentials(ref err) => err.description(),
BuildSuggestersError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
BuildSuggestersError::ParseError(ref cause) => cause,
BuildSuggestersError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateDomainError {
Base(String),
Internal(String),
LimitExceeded(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CreateDomainError {
pub fn from_response(res: BufferedHttpResponse) -> CreateDomainError {
{
let reader = EventReader::new(res.body.as_slice());
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 CreateDomainError::Base(String::from(parsed_error.message))
}
"InternalException" => {
return CreateDomainError::Internal(String::from(parsed_error.message))
}
"LimitExceeded" => {
return CreateDomainError::LimitExceeded(String::from(parsed_error.message))
}
_ => {}
}
}
}
CreateDomainError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for CreateDomainError {
fn from(err: XmlParseError) -> CreateDomainError {
let XmlParseError(message) = err;
CreateDomainError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for CreateDomainError {
fn from(err: CredentialsError) -> CreateDomainError {
CreateDomainError::Credentials(err)
}
}
impl From<HttpDispatchError> for CreateDomainError {
fn from(err: HttpDispatchError) -> CreateDomainError {
CreateDomainError::HttpDispatch(err)
}
}
impl From<io::Error> for CreateDomainError {
fn from(err: io::Error) -> CreateDomainError {
CreateDomainError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CreateDomainError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateDomainError {
fn description(&self) -> &str {
match *self {
CreateDomainError::Base(ref cause) => cause,
CreateDomainError::Internal(ref cause) => cause,
CreateDomainError::LimitExceeded(ref cause) => cause,
CreateDomainError::Validation(ref cause) => cause,
CreateDomainError::Credentials(ref err) => err.description(),
CreateDomainError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
CreateDomainError::ParseError(ref cause) => cause,
CreateDomainError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DefineAnalysisSchemeError {
Base(String),
Internal(String),
InvalidType(String),
LimitExceeded(String),
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DefineAnalysisSchemeError {
pub fn from_response(res: BufferedHttpResponse) -> DefineAnalysisSchemeError {
{
let reader = EventReader::new(res.body.as_slice());
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 DefineAnalysisSchemeError::Base(String::from(parsed_error.message))
}
"InternalException" => {
return DefineAnalysisSchemeError::Internal(String::from(
parsed_error.message,
))
}
"InvalidType" => {
return DefineAnalysisSchemeError::InvalidType(String::from(
parsed_error.message,
))
}
"LimitExceeded" => {
return DefineAnalysisSchemeError::LimitExceeded(String::from(
parsed_error.message,
))
}
"ResourceNotFound" => {
return DefineAnalysisSchemeError::ResourceNotFound(String::from(
parsed_error.message,
))
}
_ => {}
}
}
}
DefineAnalysisSchemeError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for DefineAnalysisSchemeError {
fn from(err: XmlParseError) -> DefineAnalysisSchemeError {
let XmlParseError(message) = err;
DefineAnalysisSchemeError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DefineAnalysisSchemeError {
fn from(err: CredentialsError) -> DefineAnalysisSchemeError {
DefineAnalysisSchemeError::Credentials(err)
}
}
impl From<HttpDispatchError> for DefineAnalysisSchemeError {
fn from(err: HttpDispatchError) -> DefineAnalysisSchemeError {
DefineAnalysisSchemeError::HttpDispatch(err)
}
}
impl From<io::Error> for DefineAnalysisSchemeError {
fn from(err: io::Error) -> DefineAnalysisSchemeError {
DefineAnalysisSchemeError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DefineAnalysisSchemeError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DefineAnalysisSchemeError {
fn description(&self) -> &str {
match *self {
DefineAnalysisSchemeError::Base(ref cause) => cause,
DefineAnalysisSchemeError::Internal(ref cause) => cause,
DefineAnalysisSchemeError::InvalidType(ref cause) => cause,
DefineAnalysisSchemeError::LimitExceeded(ref cause) => cause,
DefineAnalysisSchemeError::ResourceNotFound(ref cause) => cause,
DefineAnalysisSchemeError::Validation(ref cause) => cause,
DefineAnalysisSchemeError::Credentials(ref err) => err.description(),
DefineAnalysisSchemeError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DefineAnalysisSchemeError::ParseError(ref cause) => cause,
DefineAnalysisSchemeError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DefineExpressionError {
Base(String),
Internal(String),
InvalidType(String),
LimitExceeded(String),
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DefineExpressionError {
pub fn from_response(res: BufferedHttpResponse) -> DefineExpressionError {
{
let reader = EventReader::new(res.body.as_slice());
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 DefineExpressionError::Base(String::from(parsed_error.message))
}
"InternalException" => {
return DefineExpressionError::Internal(String::from(parsed_error.message))
}
"InvalidType" => {
return DefineExpressionError::InvalidType(String::from(
parsed_error.message,
))
}
"LimitExceeded" => {
return DefineExpressionError::LimitExceeded(String::from(
parsed_error.message,
))
}
"ResourceNotFound" => {
return DefineExpressionError::ResourceNotFound(String::from(
parsed_error.message,
))
}
_ => {}
}
}
}
DefineExpressionError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for DefineExpressionError {
fn from(err: XmlParseError) -> DefineExpressionError {
let XmlParseError(message) = err;
DefineExpressionError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DefineExpressionError {
fn from(err: CredentialsError) -> DefineExpressionError {
DefineExpressionError::Credentials(err)
}
}
impl From<HttpDispatchError> for DefineExpressionError {
fn from(err: HttpDispatchError) -> DefineExpressionError {
DefineExpressionError::HttpDispatch(err)
}
}
impl From<io::Error> for DefineExpressionError {
fn from(err: io::Error) -> DefineExpressionError {
DefineExpressionError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DefineExpressionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DefineExpressionError {
fn description(&self) -> &str {
match *self {
DefineExpressionError::Base(ref cause) => cause,
DefineExpressionError::Internal(ref cause) => cause,
DefineExpressionError::InvalidType(ref cause) => cause,
DefineExpressionError::LimitExceeded(ref cause) => cause,
DefineExpressionError::ResourceNotFound(ref cause) => cause,
DefineExpressionError::Validation(ref cause) => cause,
DefineExpressionError::Credentials(ref err) => err.description(),
DefineExpressionError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
DefineExpressionError::ParseError(ref cause) => cause,
DefineExpressionError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DefineIndexFieldError {
Base(String),
Internal(String),
InvalidType(String),
LimitExceeded(String),
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DefineIndexFieldError {
pub fn from_response(res: BufferedHttpResponse) -> DefineIndexFieldError {
{
let reader = EventReader::new(res.body.as_slice());
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 DefineIndexFieldError::Base(String::from(parsed_error.message))
}
"InternalException" => {
return DefineIndexFieldError::Internal(String::from(parsed_error.message))
}
"InvalidType" => {
return DefineIndexFieldError::InvalidType(String::from(
parsed_error.message,
))
}
"LimitExceeded" => {
return DefineIndexFieldError::LimitExceeded(String::from(
parsed_error.message,
))
}
"ResourceNotFound" => {
return DefineIndexFieldError::ResourceNotFound(String::from(
parsed_error.message,
))
}
_ => {}
}
}
}
DefineIndexFieldError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for DefineIndexFieldError {
fn from(err: XmlParseError) -> DefineIndexFieldError {
let XmlParseError(message) = err;
DefineIndexFieldError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DefineIndexFieldError {
fn from(err: CredentialsError) -> DefineIndexFieldError {
DefineIndexFieldError::Credentials(err)
}
}
impl From<HttpDispatchError> for DefineIndexFieldError {
fn from(err: HttpDispatchError) -> DefineIndexFieldError {
DefineIndexFieldError::HttpDispatch(err)
}
}
impl From<io::Error> for DefineIndexFieldError {
fn from(err: io::Error) -> DefineIndexFieldError {
DefineIndexFieldError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DefineIndexFieldError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DefineIndexFieldError {
fn description(&self) -> &str {
match *self {
DefineIndexFieldError::Base(ref cause) => cause,
DefineIndexFieldError::Internal(ref cause) => cause,
DefineIndexFieldError::InvalidType(ref cause) => cause,
DefineIndexFieldError::LimitExceeded(ref cause) => cause,
DefineIndexFieldError::ResourceNotFound(ref cause) => cause,
DefineIndexFieldError::Validation(ref cause) => cause,
DefineIndexFieldError::Credentials(ref err) => err.description(),
DefineIndexFieldError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
DefineIndexFieldError::ParseError(ref cause) => cause,
DefineIndexFieldError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DefineSuggesterError {
Base(String),
Internal(String),
InvalidType(String),
LimitExceeded(String),
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DefineSuggesterError {
pub fn from_response(res: BufferedHttpResponse) -> DefineSuggesterError {
{
let reader = EventReader::new(res.body.as_slice());
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 DefineSuggesterError::Base(String::from(parsed_error.message))
}
"InternalException" => {
return DefineSuggesterError::Internal(String::from(parsed_error.message))
}
"InvalidType" => {
return DefineSuggesterError::InvalidType(String::from(parsed_error.message))
}
"LimitExceeded" => {
return DefineSuggesterError::LimitExceeded(String::from(
parsed_error.message,
))
}
"ResourceNotFound" => {
return DefineSuggesterError::ResourceNotFound(String::from(
parsed_error.message,
))
}
_ => {}
}
}
}
DefineSuggesterError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for DefineSuggesterError {
fn from(err: XmlParseError) -> DefineSuggesterError {
let XmlParseError(message) = err;
DefineSuggesterError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DefineSuggesterError {
fn from(err: CredentialsError) -> DefineSuggesterError {
DefineSuggesterError::Credentials(err)
}
}
impl From<HttpDispatchError> for DefineSuggesterError {
fn from(err: HttpDispatchError) -> DefineSuggesterError {
DefineSuggesterError::HttpDispatch(err)
}
}
impl From<io::Error> for DefineSuggesterError {
fn from(err: io::Error) -> DefineSuggesterError {
DefineSuggesterError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DefineSuggesterError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DefineSuggesterError {
fn description(&self) -> &str {
match *self {
DefineSuggesterError::Base(ref cause) => cause,
DefineSuggesterError::Internal(ref cause) => cause,
DefineSuggesterError::InvalidType(ref cause) => cause,
DefineSuggesterError::LimitExceeded(ref cause) => cause,
DefineSuggesterError::ResourceNotFound(ref cause) => cause,
DefineSuggesterError::Validation(ref cause) => cause,
DefineSuggesterError::Credentials(ref err) => err.description(),
DefineSuggesterError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
DefineSuggesterError::ParseError(ref cause) => cause,
DefineSuggesterError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteAnalysisSchemeError {
Base(String),
Internal(String),
InvalidType(String),
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DeleteAnalysisSchemeError {
pub fn from_response(res: BufferedHttpResponse) -> DeleteAnalysisSchemeError {
{
let reader = EventReader::new(res.body.as_slice());
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 DeleteAnalysisSchemeError::Base(String::from(parsed_error.message))
}
"InternalException" => {
return DeleteAnalysisSchemeError::Internal(String::from(
parsed_error.message,
))
}
"InvalidType" => {
return DeleteAnalysisSchemeError::InvalidType(String::from(
parsed_error.message,
))
}
"ResourceNotFound" => {
return DeleteAnalysisSchemeError::ResourceNotFound(String::from(
parsed_error.message,
))
}
_ => {}
}
}
}
DeleteAnalysisSchemeError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for DeleteAnalysisSchemeError {
fn from(err: XmlParseError) -> DeleteAnalysisSchemeError {
let XmlParseError(message) = err;
DeleteAnalysisSchemeError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DeleteAnalysisSchemeError {
fn from(err: CredentialsError) -> DeleteAnalysisSchemeError {
DeleteAnalysisSchemeError::Credentials(err)
}
}
impl From<HttpDispatchError> for DeleteAnalysisSchemeError {
fn from(err: HttpDispatchError) -> DeleteAnalysisSchemeError {
DeleteAnalysisSchemeError::HttpDispatch(err)
}
}
impl From<io::Error> for DeleteAnalysisSchemeError {
fn from(err: io::Error) -> DeleteAnalysisSchemeError {
DeleteAnalysisSchemeError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DeleteAnalysisSchemeError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteAnalysisSchemeError {
fn description(&self) -> &str {
match *self {
DeleteAnalysisSchemeError::Base(ref cause) => cause,
DeleteAnalysisSchemeError::Internal(ref cause) => cause,
DeleteAnalysisSchemeError::InvalidType(ref cause) => cause,
DeleteAnalysisSchemeError::ResourceNotFound(ref cause) => cause,
DeleteAnalysisSchemeError::Validation(ref cause) => cause,
DeleteAnalysisSchemeError::Credentials(ref err) => err.description(),
DeleteAnalysisSchemeError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DeleteAnalysisSchemeError::ParseError(ref cause) => cause,
DeleteAnalysisSchemeError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteDomainError {
Base(String),
Internal(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DeleteDomainError {
pub fn from_response(res: BufferedHttpResponse) -> DeleteDomainError {
{
let reader = EventReader::new(res.body.as_slice());
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 DeleteDomainError::Base(String::from(parsed_error.message))
}
"InternalException" => {
return DeleteDomainError::Internal(String::from(parsed_error.message))
}
_ => {}
}
}
}
DeleteDomainError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for DeleteDomainError {
fn from(err: XmlParseError) -> DeleteDomainError {
let XmlParseError(message) = err;
DeleteDomainError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DeleteDomainError {
fn from(err: CredentialsError) -> DeleteDomainError {
DeleteDomainError::Credentials(err)
}
}
impl From<HttpDispatchError> for DeleteDomainError {
fn from(err: HttpDispatchError) -> DeleteDomainError {
DeleteDomainError::HttpDispatch(err)
}
}
impl From<io::Error> for DeleteDomainError {
fn from(err: io::Error) -> DeleteDomainError {
DeleteDomainError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DeleteDomainError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteDomainError {
fn description(&self) -> &str {
match *self {
DeleteDomainError::Base(ref cause) => cause,
DeleteDomainError::Internal(ref cause) => cause,
DeleteDomainError::Validation(ref cause) => cause,
DeleteDomainError::Credentials(ref err) => err.description(),
DeleteDomainError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
DeleteDomainError::ParseError(ref cause) => cause,
DeleteDomainError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteExpressionError {
Base(String),
Internal(String),
InvalidType(String),
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DeleteExpressionError {
pub fn from_response(res: BufferedHttpResponse) -> DeleteExpressionError {
{
let reader = EventReader::new(res.body.as_slice());
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 DeleteExpressionError::Base(String::from(parsed_error.message))
}
"InternalException" => {
return DeleteExpressionError::Internal(String::from(parsed_error.message))
}
"InvalidType" => {
return DeleteExpressionError::InvalidType(String::from(
parsed_error.message,
))
}
"ResourceNotFound" => {
return DeleteExpressionError::ResourceNotFound(String::from(
parsed_error.message,
))
}
_ => {}
}
}
}
DeleteExpressionError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for DeleteExpressionError {
fn from(err: XmlParseError) -> DeleteExpressionError {
let XmlParseError(message) = err;
DeleteExpressionError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DeleteExpressionError {
fn from(err: CredentialsError) -> DeleteExpressionError {
DeleteExpressionError::Credentials(err)
}
}
impl From<HttpDispatchError> for DeleteExpressionError {
fn from(err: HttpDispatchError) -> DeleteExpressionError {
DeleteExpressionError::HttpDispatch(err)
}
}
impl From<io::Error> for DeleteExpressionError {
fn from(err: io::Error) -> DeleteExpressionError {
DeleteExpressionError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DeleteExpressionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteExpressionError {
fn description(&self) -> &str {
match *self {
DeleteExpressionError::Base(ref cause) => cause,
DeleteExpressionError::Internal(ref cause) => cause,
DeleteExpressionError::InvalidType(ref cause) => cause,
DeleteExpressionError::ResourceNotFound(ref cause) => cause,
DeleteExpressionError::Validation(ref cause) => cause,
DeleteExpressionError::Credentials(ref err) => err.description(),
DeleteExpressionError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
DeleteExpressionError::ParseError(ref cause) => cause,
DeleteExpressionError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteIndexFieldError {
Base(String),
Internal(String),
InvalidType(String),
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DeleteIndexFieldError {
pub fn from_response(res: BufferedHttpResponse) -> DeleteIndexFieldError {
{
let reader = EventReader::new(res.body.as_slice());
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 DeleteIndexFieldError::Base(String::from(parsed_error.message))
}
"InternalException" => {
return DeleteIndexFieldError::Internal(String::from(parsed_error.message))
}
"InvalidType" => {
return DeleteIndexFieldError::InvalidType(String::from(
parsed_error.message,
))
}
"ResourceNotFound" => {
return DeleteIndexFieldError::ResourceNotFound(String::from(
parsed_error.message,
))
}
_ => {}
}
}
}
DeleteIndexFieldError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for DeleteIndexFieldError {
fn from(err: XmlParseError) -> DeleteIndexFieldError {
let XmlParseError(message) = err;
DeleteIndexFieldError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DeleteIndexFieldError {
fn from(err: CredentialsError) -> DeleteIndexFieldError {
DeleteIndexFieldError::Credentials(err)
}
}
impl From<HttpDispatchError> for DeleteIndexFieldError {
fn from(err: HttpDispatchError) -> DeleteIndexFieldError {
DeleteIndexFieldError::HttpDispatch(err)
}
}
impl From<io::Error> for DeleteIndexFieldError {
fn from(err: io::Error) -> DeleteIndexFieldError {
DeleteIndexFieldError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DeleteIndexFieldError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteIndexFieldError {
fn description(&self) -> &str {
match *self {
DeleteIndexFieldError::Base(ref cause) => cause,
DeleteIndexFieldError::Internal(ref cause) => cause,
DeleteIndexFieldError::InvalidType(ref cause) => cause,
DeleteIndexFieldError::ResourceNotFound(ref cause) => cause,
DeleteIndexFieldError::Validation(ref cause) => cause,
DeleteIndexFieldError::Credentials(ref err) => err.description(),
DeleteIndexFieldError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
DeleteIndexFieldError::ParseError(ref cause) => cause,
DeleteIndexFieldError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteSuggesterError {
Base(String),
Internal(String),
InvalidType(String),
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DeleteSuggesterError {
pub fn from_response(res: BufferedHttpResponse) -> DeleteSuggesterError {
{
let reader = EventReader::new(res.body.as_slice());
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 DeleteSuggesterError::Base(String::from(parsed_error.message))
}
"InternalException" => {
return DeleteSuggesterError::Internal(String::from(parsed_error.message))
}
"InvalidType" => {
return DeleteSuggesterError::InvalidType(String::from(parsed_error.message))
}
"ResourceNotFound" => {
return DeleteSuggesterError::ResourceNotFound(String::from(
parsed_error.message,
))
}
_ => {}
}
}
}
DeleteSuggesterError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for DeleteSuggesterError {
fn from(err: XmlParseError) -> DeleteSuggesterError {
let XmlParseError(message) = err;
DeleteSuggesterError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DeleteSuggesterError {
fn from(err: CredentialsError) -> DeleteSuggesterError {
DeleteSuggesterError::Credentials(err)
}
}
impl From<HttpDispatchError> for DeleteSuggesterError {
fn from(err: HttpDispatchError) -> DeleteSuggesterError {
DeleteSuggesterError::HttpDispatch(err)
}
}
impl From<io::Error> for DeleteSuggesterError {
fn from(err: io::Error) -> DeleteSuggesterError {
DeleteSuggesterError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DeleteSuggesterError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteSuggesterError {
fn description(&self) -> &str {
match *self {
DeleteSuggesterError::Base(ref cause) => cause,
DeleteSuggesterError::Internal(ref cause) => cause,
DeleteSuggesterError::InvalidType(ref cause) => cause,
DeleteSuggesterError::ResourceNotFound(ref cause) => cause,
DeleteSuggesterError::Validation(ref cause) => cause,
DeleteSuggesterError::Credentials(ref err) => err.description(),
DeleteSuggesterError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
DeleteSuggesterError::ParseError(ref cause) => cause,
DeleteSuggesterError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeAnalysisSchemesError {
Base(String),
Internal(String),
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeAnalysisSchemesError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeAnalysisSchemesError {
{
let reader = EventReader::new(res.body.as_slice());
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 DescribeAnalysisSchemesError::Base(String::from(
parsed_error.message,
))
}
"InternalException" => {
return DescribeAnalysisSchemesError::Internal(String::from(
parsed_error.message,
))
}
"ResourceNotFound" => {
return DescribeAnalysisSchemesError::ResourceNotFound(String::from(
parsed_error.message,
))
}
_ => {}
}
}
}
DescribeAnalysisSchemesError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for DescribeAnalysisSchemesError {
fn from(err: XmlParseError) -> DescribeAnalysisSchemesError {
let XmlParseError(message) = err;
DescribeAnalysisSchemesError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DescribeAnalysisSchemesError {
fn from(err: CredentialsError) -> DescribeAnalysisSchemesError {
DescribeAnalysisSchemesError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeAnalysisSchemesError {
fn from(err: HttpDispatchError) -> DescribeAnalysisSchemesError {
DescribeAnalysisSchemesError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeAnalysisSchemesError {
fn from(err: io::Error) -> DescribeAnalysisSchemesError {
DescribeAnalysisSchemesError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeAnalysisSchemesError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeAnalysisSchemesError {
fn description(&self) -> &str {
match *self {
DescribeAnalysisSchemesError::Base(ref cause) => cause,
DescribeAnalysisSchemesError::Internal(ref cause) => cause,
DescribeAnalysisSchemesError::ResourceNotFound(ref cause) => cause,
DescribeAnalysisSchemesError::Validation(ref cause) => cause,
DescribeAnalysisSchemesError::Credentials(ref err) => err.description(),
DescribeAnalysisSchemesError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DescribeAnalysisSchemesError::ParseError(ref cause) => cause,
DescribeAnalysisSchemesError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeAvailabilityOptionsError {
Base(String),
DisabledOperation(String),
Internal(String),
InvalidType(String),
LimitExceeded(String),
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeAvailabilityOptionsError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeAvailabilityOptionsError {
{
let reader = EventReader::new(res.body.as_slice());
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 DescribeAvailabilityOptionsError::Base(String::from(
parsed_error.message,
))
}
"DisabledAction" => {
return DescribeAvailabilityOptionsError::DisabledOperation(String::from(
parsed_error.message,
))
}
"InternalException" => {
return DescribeAvailabilityOptionsError::Internal(String::from(
parsed_error.message,
))
}
"InvalidType" => {
return DescribeAvailabilityOptionsError::InvalidType(String::from(
parsed_error.message,
))
}
"LimitExceeded" => {
return DescribeAvailabilityOptionsError::LimitExceeded(String::from(
parsed_error.message,
))
}
"ResourceNotFound" => {
return DescribeAvailabilityOptionsError::ResourceNotFound(String::from(
parsed_error.message,
))
}
_ => {}
}
}
}
DescribeAvailabilityOptionsError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for DescribeAvailabilityOptionsError {
fn from(err: XmlParseError) -> DescribeAvailabilityOptionsError {
let XmlParseError(message) = err;
DescribeAvailabilityOptionsError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DescribeAvailabilityOptionsError {
fn from(err: CredentialsError) -> DescribeAvailabilityOptionsError {
DescribeAvailabilityOptionsError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeAvailabilityOptionsError {
fn from(err: HttpDispatchError) -> DescribeAvailabilityOptionsError {
DescribeAvailabilityOptionsError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeAvailabilityOptionsError {
fn from(err: io::Error) -> DescribeAvailabilityOptionsError {
DescribeAvailabilityOptionsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeAvailabilityOptionsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeAvailabilityOptionsError {
fn description(&self) -> &str {
match *self {
DescribeAvailabilityOptionsError::Base(ref cause) => cause,
DescribeAvailabilityOptionsError::DisabledOperation(ref cause) => cause,
DescribeAvailabilityOptionsError::Internal(ref cause) => cause,
DescribeAvailabilityOptionsError::InvalidType(ref cause) => cause,
DescribeAvailabilityOptionsError::LimitExceeded(ref cause) => cause,
DescribeAvailabilityOptionsError::ResourceNotFound(ref cause) => cause,
DescribeAvailabilityOptionsError::Validation(ref cause) => cause,
DescribeAvailabilityOptionsError::Credentials(ref err) => err.description(),
DescribeAvailabilityOptionsError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DescribeAvailabilityOptionsError::ParseError(ref cause) => cause,
DescribeAvailabilityOptionsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeDomainsError {
Base(String),
Internal(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeDomainsError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeDomainsError {
{
let reader = EventReader::new(res.body.as_slice());
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 DescribeDomainsError::Base(String::from(parsed_error.message))
}
"InternalException" => {
return DescribeDomainsError::Internal(String::from(parsed_error.message))
}
_ => {}
}
}
}
DescribeDomainsError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for DescribeDomainsError {
fn from(err: XmlParseError) -> DescribeDomainsError {
let XmlParseError(message) = err;
DescribeDomainsError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DescribeDomainsError {
fn from(err: CredentialsError) -> DescribeDomainsError {
DescribeDomainsError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeDomainsError {
fn from(err: HttpDispatchError) -> DescribeDomainsError {
DescribeDomainsError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeDomainsError {
fn from(err: io::Error) -> DescribeDomainsError {
DescribeDomainsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeDomainsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeDomainsError {
fn description(&self) -> &str {
match *self {
DescribeDomainsError::Base(ref cause) => cause,
DescribeDomainsError::Internal(ref cause) => cause,
DescribeDomainsError::Validation(ref cause) => cause,
DescribeDomainsError::Credentials(ref err) => err.description(),
DescribeDomainsError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
DescribeDomainsError::ParseError(ref cause) => cause,
DescribeDomainsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeExpressionsError {
Base(String),
Internal(String),
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeExpressionsError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeExpressionsError {
{
let reader = EventReader::new(res.body.as_slice());
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 DescribeExpressionsError::Base(String::from(parsed_error.message))
}
"InternalException" => {
return DescribeExpressionsError::Internal(String::from(
parsed_error.message,
))
}
"ResourceNotFound" => {
return DescribeExpressionsError::ResourceNotFound(String::from(
parsed_error.message,
))
}
_ => {}
}
}
}
DescribeExpressionsError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for DescribeExpressionsError {
fn from(err: XmlParseError) -> DescribeExpressionsError {
let XmlParseError(message) = err;
DescribeExpressionsError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DescribeExpressionsError {
fn from(err: CredentialsError) -> DescribeExpressionsError {
DescribeExpressionsError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeExpressionsError {
fn from(err: HttpDispatchError) -> DescribeExpressionsError {
DescribeExpressionsError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeExpressionsError {
fn from(err: io::Error) -> DescribeExpressionsError {
DescribeExpressionsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeExpressionsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeExpressionsError {
fn description(&self) -> &str {
match *self {
DescribeExpressionsError::Base(ref cause) => cause,
DescribeExpressionsError::Internal(ref cause) => cause,
DescribeExpressionsError::ResourceNotFound(ref cause) => cause,
DescribeExpressionsError::Validation(ref cause) => cause,
DescribeExpressionsError::Credentials(ref err) => err.description(),
DescribeExpressionsError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DescribeExpressionsError::ParseError(ref cause) => cause,
DescribeExpressionsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeIndexFieldsError {
Base(String),
Internal(String),
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeIndexFieldsError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeIndexFieldsError {
{
let reader = EventReader::new(res.body.as_slice());
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 DescribeIndexFieldsError::Base(String::from(parsed_error.message))
}
"InternalException" => {
return DescribeIndexFieldsError::Internal(String::from(
parsed_error.message,
))
}
"ResourceNotFound" => {
return DescribeIndexFieldsError::ResourceNotFound(String::from(
parsed_error.message,
))
}
_ => {}
}
}
}
DescribeIndexFieldsError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for DescribeIndexFieldsError {
fn from(err: XmlParseError) -> DescribeIndexFieldsError {
let XmlParseError(message) = err;
DescribeIndexFieldsError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DescribeIndexFieldsError {
fn from(err: CredentialsError) -> DescribeIndexFieldsError {
DescribeIndexFieldsError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeIndexFieldsError {
fn from(err: HttpDispatchError) -> DescribeIndexFieldsError {
DescribeIndexFieldsError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeIndexFieldsError {
fn from(err: io::Error) -> DescribeIndexFieldsError {
DescribeIndexFieldsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeIndexFieldsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeIndexFieldsError {
fn description(&self) -> &str {
match *self {
DescribeIndexFieldsError::Base(ref cause) => cause,
DescribeIndexFieldsError::Internal(ref cause) => cause,
DescribeIndexFieldsError::ResourceNotFound(ref cause) => cause,
DescribeIndexFieldsError::Validation(ref cause) => cause,
DescribeIndexFieldsError::Credentials(ref err) => err.description(),
DescribeIndexFieldsError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DescribeIndexFieldsError::ParseError(ref cause) => cause,
DescribeIndexFieldsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeScalingParametersError {
Base(String),
Internal(String),
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeScalingParametersError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeScalingParametersError {
{
let reader = EventReader::new(res.body.as_slice());
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 DescribeScalingParametersError::Base(String::from(
parsed_error.message,
))
}
"InternalException" => {
return DescribeScalingParametersError::Internal(String::from(
parsed_error.message,
))
}
"ResourceNotFound" => {
return DescribeScalingParametersError::ResourceNotFound(String::from(
parsed_error.message,
))
}
_ => {}
}
}
}
DescribeScalingParametersError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for DescribeScalingParametersError {
fn from(err: XmlParseError) -> DescribeScalingParametersError {
let XmlParseError(message) = err;
DescribeScalingParametersError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DescribeScalingParametersError {
fn from(err: CredentialsError) -> DescribeScalingParametersError {
DescribeScalingParametersError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeScalingParametersError {
fn from(err: HttpDispatchError) -> DescribeScalingParametersError {
DescribeScalingParametersError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeScalingParametersError {
fn from(err: io::Error) -> DescribeScalingParametersError {
DescribeScalingParametersError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeScalingParametersError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeScalingParametersError {
fn description(&self) -> &str {
match *self {
DescribeScalingParametersError::Base(ref cause) => cause,
DescribeScalingParametersError::Internal(ref cause) => cause,
DescribeScalingParametersError::ResourceNotFound(ref cause) => cause,
DescribeScalingParametersError::Validation(ref cause) => cause,
DescribeScalingParametersError::Credentials(ref err) => err.description(),
DescribeScalingParametersError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DescribeScalingParametersError::ParseError(ref cause) => cause,
DescribeScalingParametersError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeServiceAccessPoliciesError {
Base(String),
Internal(String),
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeServiceAccessPoliciesError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeServiceAccessPoliciesError {
{
let reader = EventReader::new(res.body.as_slice());
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 DescribeServiceAccessPoliciesError::Base(String::from(
parsed_error.message,
))
}
"InternalException" => {
return DescribeServiceAccessPoliciesError::Internal(String::from(
parsed_error.message,
))
}
"ResourceNotFound" => {
return DescribeServiceAccessPoliciesError::ResourceNotFound(String::from(
parsed_error.message,
))
}
_ => {}
}
}
}
DescribeServiceAccessPoliciesError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for DescribeServiceAccessPoliciesError {
fn from(err: XmlParseError) -> DescribeServiceAccessPoliciesError {
let XmlParseError(message) = err;
DescribeServiceAccessPoliciesError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DescribeServiceAccessPoliciesError {
fn from(err: CredentialsError) -> DescribeServiceAccessPoliciesError {
DescribeServiceAccessPoliciesError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeServiceAccessPoliciesError {
fn from(err: HttpDispatchError) -> DescribeServiceAccessPoliciesError {
DescribeServiceAccessPoliciesError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeServiceAccessPoliciesError {
fn from(err: io::Error) -> DescribeServiceAccessPoliciesError {
DescribeServiceAccessPoliciesError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeServiceAccessPoliciesError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeServiceAccessPoliciesError {
fn description(&self) -> &str {
match *self {
DescribeServiceAccessPoliciesError::Base(ref cause) => cause,
DescribeServiceAccessPoliciesError::Internal(ref cause) => cause,
DescribeServiceAccessPoliciesError::ResourceNotFound(ref cause) => cause,
DescribeServiceAccessPoliciesError::Validation(ref cause) => cause,
DescribeServiceAccessPoliciesError::Credentials(ref err) => err.description(),
DescribeServiceAccessPoliciesError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DescribeServiceAccessPoliciesError::ParseError(ref cause) => cause,
DescribeServiceAccessPoliciesError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeSuggestersError {
Base(String),
Internal(String),
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeSuggestersError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeSuggestersError {
{
let reader = EventReader::new(res.body.as_slice());
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 DescribeSuggestersError::Base(String::from(parsed_error.message))
}
"InternalException" => {
return DescribeSuggestersError::Internal(String::from(parsed_error.message))
}
"ResourceNotFound" => {
return DescribeSuggestersError::ResourceNotFound(String::from(
parsed_error.message,
))
}
_ => {}
}
}
}
DescribeSuggestersError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for DescribeSuggestersError {
fn from(err: XmlParseError) -> DescribeSuggestersError {
let XmlParseError(message) = err;
DescribeSuggestersError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DescribeSuggestersError {
fn from(err: CredentialsError) -> DescribeSuggestersError {
DescribeSuggestersError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeSuggestersError {
fn from(err: HttpDispatchError) -> DescribeSuggestersError {
DescribeSuggestersError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeSuggestersError {
fn from(err: io::Error) -> DescribeSuggestersError {
DescribeSuggestersError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeSuggestersError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeSuggestersError {
fn description(&self) -> &str {
match *self {
DescribeSuggestersError::Base(ref cause) => cause,
DescribeSuggestersError::Internal(ref cause) => cause,
DescribeSuggestersError::ResourceNotFound(ref cause) => cause,
DescribeSuggestersError::Validation(ref cause) => cause,
DescribeSuggestersError::Credentials(ref err) => err.description(),
DescribeSuggestersError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DescribeSuggestersError::ParseError(ref cause) => cause,
DescribeSuggestersError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum IndexDocumentsError {
Base(String),
Internal(String),
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl IndexDocumentsError {
pub fn from_response(res: BufferedHttpResponse) -> IndexDocumentsError {
{
let reader = EventReader::new(res.body.as_slice());
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 IndexDocumentsError::Base(String::from(parsed_error.message))
}
"InternalException" => {
return IndexDocumentsError::Internal(String::from(parsed_error.message))
}
"ResourceNotFound" => {
return IndexDocumentsError::ResourceNotFound(String::from(
parsed_error.message,
))
}
_ => {}
}
}
}
IndexDocumentsError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for IndexDocumentsError {
fn from(err: XmlParseError) -> IndexDocumentsError {
let XmlParseError(message) = err;
IndexDocumentsError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for IndexDocumentsError {
fn from(err: CredentialsError) -> IndexDocumentsError {
IndexDocumentsError::Credentials(err)
}
}
impl From<HttpDispatchError> for IndexDocumentsError {
fn from(err: HttpDispatchError) -> IndexDocumentsError {
IndexDocumentsError::HttpDispatch(err)
}
}
impl From<io::Error> for IndexDocumentsError {
fn from(err: io::Error) -> IndexDocumentsError {
IndexDocumentsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for IndexDocumentsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for IndexDocumentsError {
fn description(&self) -> &str {
match *self {
IndexDocumentsError::Base(ref cause) => cause,
IndexDocumentsError::Internal(ref cause) => cause,
IndexDocumentsError::ResourceNotFound(ref cause) => cause,
IndexDocumentsError::Validation(ref cause) => cause,
IndexDocumentsError::Credentials(ref err) => err.description(),
IndexDocumentsError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
IndexDocumentsError::ParseError(ref cause) => cause,
IndexDocumentsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ListDomainNamesError {
Base(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ListDomainNamesError {
pub fn from_response(res: BufferedHttpResponse) -> ListDomainNamesError {
{
let reader = EventReader::new(res.body.as_slice());
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 ListDomainNamesError::Base(String::from(parsed_error.message))
}
_ => {}
}
}
}
ListDomainNamesError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for ListDomainNamesError {
fn from(err: XmlParseError) -> ListDomainNamesError {
let XmlParseError(message) = err;
ListDomainNamesError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for ListDomainNamesError {
fn from(err: CredentialsError) -> ListDomainNamesError {
ListDomainNamesError::Credentials(err)
}
}
impl From<HttpDispatchError> for ListDomainNamesError {
fn from(err: HttpDispatchError) -> ListDomainNamesError {
ListDomainNamesError::HttpDispatch(err)
}
}
impl From<io::Error> for ListDomainNamesError {
fn from(err: io::Error) -> ListDomainNamesError {
ListDomainNamesError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ListDomainNamesError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ListDomainNamesError {
fn description(&self) -> &str {
match *self {
ListDomainNamesError::Base(ref cause) => cause,
ListDomainNamesError::Validation(ref cause) => cause,
ListDomainNamesError::Credentials(ref err) => err.description(),
ListDomainNamesError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
ListDomainNamesError::ParseError(ref cause) => cause,
ListDomainNamesError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum UpdateAvailabilityOptionsError {
Base(String),
DisabledOperation(String),
Internal(String),
InvalidType(String),
LimitExceeded(String),
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl UpdateAvailabilityOptionsError {
pub fn from_response(res: BufferedHttpResponse) -> UpdateAvailabilityOptionsError {
{
let reader = EventReader::new(res.body.as_slice());
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 UpdateAvailabilityOptionsError::Base(String::from(
parsed_error.message,
))
}
"DisabledAction" => {
return UpdateAvailabilityOptionsError::DisabledOperation(String::from(
parsed_error.message,
))
}
"InternalException" => {
return UpdateAvailabilityOptionsError::Internal(String::from(
parsed_error.message,
))
}
"InvalidType" => {
return UpdateAvailabilityOptionsError::InvalidType(String::from(
parsed_error.message,
))
}
"LimitExceeded" => {
return UpdateAvailabilityOptionsError::LimitExceeded(String::from(
parsed_error.message,
))
}
"ResourceNotFound" => {
return UpdateAvailabilityOptionsError::ResourceNotFound(String::from(
parsed_error.message,
))
}
_ => {}
}
}
}
UpdateAvailabilityOptionsError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for UpdateAvailabilityOptionsError {
fn from(err: XmlParseError) -> UpdateAvailabilityOptionsError {
let XmlParseError(message) = err;
UpdateAvailabilityOptionsError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for UpdateAvailabilityOptionsError {
fn from(err: CredentialsError) -> UpdateAvailabilityOptionsError {
UpdateAvailabilityOptionsError::Credentials(err)
}
}
impl From<HttpDispatchError> for UpdateAvailabilityOptionsError {
fn from(err: HttpDispatchError) -> UpdateAvailabilityOptionsError {
UpdateAvailabilityOptionsError::HttpDispatch(err)
}
}
impl From<io::Error> for UpdateAvailabilityOptionsError {
fn from(err: io::Error) -> UpdateAvailabilityOptionsError {
UpdateAvailabilityOptionsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for UpdateAvailabilityOptionsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for UpdateAvailabilityOptionsError {
fn description(&self) -> &str {
match *self {
UpdateAvailabilityOptionsError::Base(ref cause) => cause,
UpdateAvailabilityOptionsError::DisabledOperation(ref cause) => cause,
UpdateAvailabilityOptionsError::Internal(ref cause) => cause,
UpdateAvailabilityOptionsError::InvalidType(ref cause) => cause,
UpdateAvailabilityOptionsError::LimitExceeded(ref cause) => cause,
UpdateAvailabilityOptionsError::ResourceNotFound(ref cause) => cause,
UpdateAvailabilityOptionsError::Validation(ref cause) => cause,
UpdateAvailabilityOptionsError::Credentials(ref err) => err.description(),
UpdateAvailabilityOptionsError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
UpdateAvailabilityOptionsError::ParseError(ref cause) => cause,
UpdateAvailabilityOptionsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum UpdateScalingParametersError {
Base(String),
Internal(String),
InvalidType(String),
LimitExceeded(String),
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl UpdateScalingParametersError {
pub fn from_response(res: BufferedHttpResponse) -> UpdateScalingParametersError {
{
let reader = EventReader::new(res.body.as_slice());
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 UpdateScalingParametersError::Base(String::from(
parsed_error.message,
))
}
"InternalException" => {
return UpdateScalingParametersError::Internal(String::from(
parsed_error.message,
))
}
"InvalidType" => {
return UpdateScalingParametersError::InvalidType(String::from(
parsed_error.message,
))
}
"LimitExceeded" => {
return UpdateScalingParametersError::LimitExceeded(String::from(
parsed_error.message,
))
}
"ResourceNotFound" => {
return UpdateScalingParametersError::ResourceNotFound(String::from(
parsed_error.message,
))
}
_ => {}
}
}
}
UpdateScalingParametersError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for UpdateScalingParametersError {
fn from(err: XmlParseError) -> UpdateScalingParametersError {
let XmlParseError(message) = err;
UpdateScalingParametersError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for UpdateScalingParametersError {
fn from(err: CredentialsError) -> UpdateScalingParametersError {
UpdateScalingParametersError::Credentials(err)
}
}
impl From<HttpDispatchError> for UpdateScalingParametersError {
fn from(err: HttpDispatchError) -> UpdateScalingParametersError {
UpdateScalingParametersError::HttpDispatch(err)
}
}
impl From<io::Error> for UpdateScalingParametersError {
fn from(err: io::Error) -> UpdateScalingParametersError {
UpdateScalingParametersError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for UpdateScalingParametersError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for UpdateScalingParametersError {
fn description(&self) -> &str {
match *self {
UpdateScalingParametersError::Base(ref cause) => cause,
UpdateScalingParametersError::Internal(ref cause) => cause,
UpdateScalingParametersError::InvalidType(ref cause) => cause,
UpdateScalingParametersError::LimitExceeded(ref cause) => cause,
UpdateScalingParametersError::ResourceNotFound(ref cause) => cause,
UpdateScalingParametersError::Validation(ref cause) => cause,
UpdateScalingParametersError::Credentials(ref err) => err.description(),
UpdateScalingParametersError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
UpdateScalingParametersError::ParseError(ref cause) => cause,
UpdateScalingParametersError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum UpdateServiceAccessPoliciesError {
Base(String),
Internal(String),
InvalidType(String),
LimitExceeded(String),
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl UpdateServiceAccessPoliciesError {
pub fn from_response(res: BufferedHttpResponse) -> UpdateServiceAccessPoliciesError {
{
let reader = EventReader::new(res.body.as_slice());
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 UpdateServiceAccessPoliciesError::Base(String::from(
parsed_error.message,
))
}
"InternalException" => {
return UpdateServiceAccessPoliciesError::Internal(String::from(
parsed_error.message,
))
}
"InvalidType" => {
return UpdateServiceAccessPoliciesError::InvalidType(String::from(
parsed_error.message,
))
}
"LimitExceeded" => {
return UpdateServiceAccessPoliciesError::LimitExceeded(String::from(
parsed_error.message,
))
}
"ResourceNotFound" => {
return UpdateServiceAccessPoliciesError::ResourceNotFound(String::from(
parsed_error.message,
))
}
_ => {}
}
}
}
UpdateServiceAccessPoliciesError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for UpdateServiceAccessPoliciesError {
fn from(err: XmlParseError) -> UpdateServiceAccessPoliciesError {
let XmlParseError(message) = err;
UpdateServiceAccessPoliciesError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for UpdateServiceAccessPoliciesError {
fn from(err: CredentialsError) -> UpdateServiceAccessPoliciesError {
UpdateServiceAccessPoliciesError::Credentials(err)
}
}
impl From<HttpDispatchError> for UpdateServiceAccessPoliciesError {
fn from(err: HttpDispatchError) -> UpdateServiceAccessPoliciesError {
UpdateServiceAccessPoliciesError::HttpDispatch(err)
}
}
impl From<io::Error> for UpdateServiceAccessPoliciesError {
fn from(err: io::Error) -> UpdateServiceAccessPoliciesError {
UpdateServiceAccessPoliciesError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for UpdateServiceAccessPoliciesError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for UpdateServiceAccessPoliciesError {
fn description(&self) -> &str {
match *self {
UpdateServiceAccessPoliciesError::Base(ref cause) => cause,
UpdateServiceAccessPoliciesError::Internal(ref cause) => cause,
UpdateServiceAccessPoliciesError::InvalidType(ref cause) => cause,
UpdateServiceAccessPoliciesError::LimitExceeded(ref cause) => cause,
UpdateServiceAccessPoliciesError::ResourceNotFound(ref cause) => cause,
UpdateServiceAccessPoliciesError::Validation(ref cause) => cause,
UpdateServiceAccessPoliciesError::Credentials(ref err) => err.description(),
UpdateServiceAccessPoliciesError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
UpdateServiceAccessPoliciesError::ParseError(ref cause) => cause,
UpdateServiceAccessPoliciesError::Unknown(_) => "unknown error",
}
}
}
pub trait CloudSearch {
fn build_suggesters(
&self,
input: BuildSuggestersRequest,
) -> RusotoFuture<BuildSuggestersResponse, BuildSuggestersError>;
fn create_domain(
&self,
input: CreateDomainRequest,
) -> RusotoFuture<CreateDomainResponse, CreateDomainError>;
fn define_analysis_scheme(
&self,
input: DefineAnalysisSchemeRequest,
) -> RusotoFuture<DefineAnalysisSchemeResponse, DefineAnalysisSchemeError>;
fn define_expression(
&self,
input: DefineExpressionRequest,
) -> RusotoFuture<DefineExpressionResponse, DefineExpressionError>;
fn define_index_field(
&self,
input: DefineIndexFieldRequest,
) -> RusotoFuture<DefineIndexFieldResponse, DefineIndexFieldError>;
fn define_suggester(
&self,
input: DefineSuggesterRequest,
) -> RusotoFuture<DefineSuggesterResponse, DefineSuggesterError>;
fn delete_analysis_scheme(
&self,
input: DeleteAnalysisSchemeRequest,
) -> RusotoFuture<DeleteAnalysisSchemeResponse, DeleteAnalysisSchemeError>;
fn delete_domain(
&self,
input: DeleteDomainRequest,
) -> RusotoFuture<DeleteDomainResponse, DeleteDomainError>;
fn delete_expression(
&self,
input: DeleteExpressionRequest,
) -> RusotoFuture<DeleteExpressionResponse, DeleteExpressionError>;
fn delete_index_field(
&self,
input: DeleteIndexFieldRequest,
) -> RusotoFuture<DeleteIndexFieldResponse, DeleteIndexFieldError>;
fn delete_suggester(
&self,
input: DeleteSuggesterRequest,
) -> RusotoFuture<DeleteSuggesterResponse, DeleteSuggesterError>;
fn describe_analysis_schemes(
&self,
input: DescribeAnalysisSchemesRequest,
) -> RusotoFuture<DescribeAnalysisSchemesResponse, DescribeAnalysisSchemesError>;
fn describe_availability_options(
&self,
input: DescribeAvailabilityOptionsRequest,
) -> RusotoFuture<DescribeAvailabilityOptionsResponse, DescribeAvailabilityOptionsError>;
fn describe_domains(
&self,
input: DescribeDomainsRequest,
) -> RusotoFuture<DescribeDomainsResponse, DescribeDomainsError>;
fn describe_expressions(
&self,
input: DescribeExpressionsRequest,
) -> RusotoFuture<DescribeExpressionsResponse, DescribeExpressionsError>;
fn describe_index_fields(
&self,
input: DescribeIndexFieldsRequest,
) -> RusotoFuture<DescribeIndexFieldsResponse, DescribeIndexFieldsError>;
fn describe_scaling_parameters(
&self,
input: DescribeScalingParametersRequest,
) -> RusotoFuture<DescribeScalingParametersResponse, DescribeScalingParametersError>;
fn describe_service_access_policies(
&self,
input: DescribeServiceAccessPoliciesRequest,
) -> RusotoFuture<DescribeServiceAccessPoliciesResponse, DescribeServiceAccessPoliciesError>;
fn describe_suggesters(
&self,
input: DescribeSuggestersRequest,
) -> RusotoFuture<DescribeSuggestersResponse, DescribeSuggestersError>;
fn index_documents(
&self,
input: IndexDocumentsRequest,
) -> RusotoFuture<IndexDocumentsResponse, IndexDocumentsError>;
fn list_domain_names(&self) -> RusotoFuture<ListDomainNamesResponse, ListDomainNamesError>;
fn update_availability_options(
&self,
input: UpdateAvailabilityOptionsRequest,
) -> RusotoFuture<UpdateAvailabilityOptionsResponse, UpdateAvailabilityOptionsError>;
fn update_scaling_parameters(
&self,
input: UpdateScalingParametersRequest,
) -> RusotoFuture<UpdateScalingParametersResponse, UpdateScalingParametersError>;
fn update_service_access_policies(
&self,
input: UpdateServiceAccessPoliciesRequest,
) -> RusotoFuture<UpdateServiceAccessPoliciesResponse, UpdateServiceAccessPoliciesError>;
}
pub struct CloudSearchClient {
client: Client,
region: region::Region,
}
impl CloudSearchClient {
pub fn new(region: region::Region) -> CloudSearchClient {
CloudSearchClient {
client: Client::shared(),
region: region,
}
}
pub fn new_with<P, D>(
request_dispatcher: D,
credentials_provider: P,
region: region::Region,
) -> CloudSearchClient
where
P: ProvideAwsCredentials + Send + Sync + 'static,
P::Future: Send,
D: DispatchSignedRequest + Send + Sync + 'static,
D::Future: Send,
{
CloudSearchClient {
client: Client::new_with(credentials_provider, request_dispatcher),
region: region,
}
}
}
impl CloudSearch for CloudSearchClient {
fn build_suggesters(
&self,
input: BuildSuggestersRequest,
) -> RusotoFuture<BuildSuggestersResponse, BuildSuggestersError> {
let mut request = SignedRequest::new("POST", "cloudsearch", &self.region, "/");
let mut params = Params::new();
params.put("Action", "BuildSuggesters");
params.put("Version", "2013-01-01");
BuildSuggestersRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(BuildSuggestersError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = BuildSuggestersResponse::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = try!(peek_at_name(&mut stack));
try!(start_element(&actual_tag_name, &mut stack));
result = try!(BuildSuggestersResponseDeserializer::deserialize(
"BuildSuggestersResult",
&mut stack
));
skip_tree(&mut stack);
try!(end_element(&actual_tag_name, &mut stack));
}
Ok(result)
}))
})
}
fn create_domain(
&self,
input: CreateDomainRequest,
) -> RusotoFuture<CreateDomainResponse, CreateDomainError> {
let mut request = SignedRequest::new("POST", "cloudsearch", &self.region, "/");
let mut params = Params::new();
params.put("Action", "CreateDomain");
params.put("Version", "2013-01-01");
CreateDomainRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(CreateDomainError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = CreateDomainResponse::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = try!(peek_at_name(&mut stack));
try!(start_element(&actual_tag_name, &mut stack));
result = try!(CreateDomainResponseDeserializer::deserialize(
"CreateDomainResult",
&mut stack
));
skip_tree(&mut stack);
try!(end_element(&actual_tag_name, &mut stack));
}
Ok(result)
}))
})
}
fn define_analysis_scheme(
&self,
input: DefineAnalysisSchemeRequest,
) -> RusotoFuture<DefineAnalysisSchemeResponse, DefineAnalysisSchemeError> {
let mut request = SignedRequest::new("POST", "cloudsearch", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DefineAnalysisScheme");
params.put("Version", "2013-01-01");
DefineAnalysisSchemeRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response.buffer().from_err().and_then(|response| {
Err(DefineAnalysisSchemeError::from_response(response))
}),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DefineAnalysisSchemeResponse::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = try!(peek_at_name(&mut stack));
try!(start_element(&actual_tag_name, &mut stack));
result = try!(DefineAnalysisSchemeResponseDeserializer::deserialize(
"DefineAnalysisSchemeResult",
&mut stack
));
skip_tree(&mut stack);
try!(end_element(&actual_tag_name, &mut stack));
}
Ok(result)
}))
})
}
fn define_expression(
&self,
input: DefineExpressionRequest,
) -> RusotoFuture<DefineExpressionResponse, DefineExpressionError> {
let mut request = SignedRequest::new("POST", "cloudsearch", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DefineExpression");
params.put("Version", "2013-01-01");
DefineExpressionRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DefineExpressionError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DefineExpressionResponse::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = try!(peek_at_name(&mut stack));
try!(start_element(&actual_tag_name, &mut stack));
result = try!(DefineExpressionResponseDeserializer::deserialize(
"DefineExpressionResult",
&mut stack
));
skip_tree(&mut stack);
try!(end_element(&actual_tag_name, &mut stack));
}
Ok(result)
}))
})
}
fn define_index_field(
&self,
input: DefineIndexFieldRequest,
) -> RusotoFuture<DefineIndexFieldResponse, DefineIndexFieldError> {
let mut request = SignedRequest::new("POST", "cloudsearch", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DefineIndexField");
params.put("Version", "2013-01-01");
DefineIndexFieldRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DefineIndexFieldError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DefineIndexFieldResponse::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = try!(peek_at_name(&mut stack));
try!(start_element(&actual_tag_name, &mut stack));
result = try!(DefineIndexFieldResponseDeserializer::deserialize(
"DefineIndexFieldResult",
&mut stack
));
skip_tree(&mut stack);
try!(end_element(&actual_tag_name, &mut stack));
}
Ok(result)
}))
})
}
fn define_suggester(
&self,
input: DefineSuggesterRequest,
) -> RusotoFuture<DefineSuggesterResponse, DefineSuggesterError> {
let mut request = SignedRequest::new("POST", "cloudsearch", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DefineSuggester");
params.put("Version", "2013-01-01");
DefineSuggesterRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DefineSuggesterError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DefineSuggesterResponse::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = try!(peek_at_name(&mut stack));
try!(start_element(&actual_tag_name, &mut stack));
result = try!(DefineSuggesterResponseDeserializer::deserialize(
"DefineSuggesterResult",
&mut stack
));
skip_tree(&mut stack);
try!(end_element(&actual_tag_name, &mut stack));
}
Ok(result)
}))
})
}
fn delete_analysis_scheme(
&self,
input: DeleteAnalysisSchemeRequest,
) -> RusotoFuture<DeleteAnalysisSchemeResponse, DeleteAnalysisSchemeError> {
let mut request = SignedRequest::new("POST", "cloudsearch", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DeleteAnalysisScheme");
params.put("Version", "2013-01-01");
DeleteAnalysisSchemeRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response.buffer().from_err().and_then(|response| {
Err(DeleteAnalysisSchemeError::from_response(response))
}),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DeleteAnalysisSchemeResponse::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = try!(peek_at_name(&mut stack));
try!(start_element(&actual_tag_name, &mut stack));
result = try!(DeleteAnalysisSchemeResponseDeserializer::deserialize(
"DeleteAnalysisSchemeResult",
&mut stack
));
skip_tree(&mut stack);
try!(end_element(&actual_tag_name, &mut stack));
}
Ok(result)
}))
})
}
fn delete_domain(
&self,
input: DeleteDomainRequest,
) -> RusotoFuture<DeleteDomainResponse, DeleteDomainError> {
let mut request = SignedRequest::new("POST", "cloudsearch", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DeleteDomain");
params.put("Version", "2013-01-01");
DeleteDomainRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DeleteDomainError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DeleteDomainResponse::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = try!(peek_at_name(&mut stack));
try!(start_element(&actual_tag_name, &mut stack));
result = try!(DeleteDomainResponseDeserializer::deserialize(
"DeleteDomainResult",
&mut stack
));
skip_tree(&mut stack);
try!(end_element(&actual_tag_name, &mut stack));
}
Ok(result)
}))
})
}
fn delete_expression(
&self,
input: DeleteExpressionRequest,
) -> RusotoFuture<DeleteExpressionResponse, DeleteExpressionError> {
let mut request = SignedRequest::new("POST", "cloudsearch", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DeleteExpression");
params.put("Version", "2013-01-01");
DeleteExpressionRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DeleteExpressionError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DeleteExpressionResponse::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = try!(peek_at_name(&mut stack));
try!(start_element(&actual_tag_name, &mut stack));
result = try!(DeleteExpressionResponseDeserializer::deserialize(
"DeleteExpressionResult",
&mut stack
));
skip_tree(&mut stack);
try!(end_element(&actual_tag_name, &mut stack));
}
Ok(result)
}))
})
}
fn delete_index_field(
&self,
input: DeleteIndexFieldRequest,
) -> RusotoFuture<DeleteIndexFieldResponse, DeleteIndexFieldError> {
let mut request = SignedRequest::new("POST", "cloudsearch", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DeleteIndexField");
params.put("Version", "2013-01-01");
DeleteIndexFieldRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DeleteIndexFieldError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DeleteIndexFieldResponse::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = try!(peek_at_name(&mut stack));
try!(start_element(&actual_tag_name, &mut stack));
result = try!(DeleteIndexFieldResponseDeserializer::deserialize(
"DeleteIndexFieldResult",
&mut stack
));
skip_tree(&mut stack);
try!(end_element(&actual_tag_name, &mut stack));
}
Ok(result)
}))
})
}
fn delete_suggester(
&self,
input: DeleteSuggesterRequest,
) -> RusotoFuture<DeleteSuggesterResponse, DeleteSuggesterError> {
let mut request = SignedRequest::new("POST", "cloudsearch", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DeleteSuggester");
params.put("Version", "2013-01-01");
DeleteSuggesterRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DeleteSuggesterError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DeleteSuggesterResponse::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = try!(peek_at_name(&mut stack));
try!(start_element(&actual_tag_name, &mut stack));
result = try!(DeleteSuggesterResponseDeserializer::deserialize(
"DeleteSuggesterResult",
&mut stack
));
skip_tree(&mut stack);
try!(end_element(&actual_tag_name, &mut stack));
}
Ok(result)
}))
})
}
fn describe_analysis_schemes(
&self,
input: DescribeAnalysisSchemesRequest,
) -> RusotoFuture<DescribeAnalysisSchemesResponse, DescribeAnalysisSchemesError> {
let mut request = SignedRequest::new("POST", "cloudsearch", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeAnalysisSchemes");
params.put("Version", "2013-01-01");
DescribeAnalysisSchemesRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeAnalysisSchemesError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeAnalysisSchemesResponse::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = try!(peek_at_name(&mut stack));
try!(start_element(&actual_tag_name, &mut stack));
result = try!(DescribeAnalysisSchemesResponseDeserializer::deserialize(
"DescribeAnalysisSchemesResult",
&mut stack
));
skip_tree(&mut stack);
try!(end_element(&actual_tag_name, &mut stack));
}
Ok(result)
}))
})
}
fn describe_availability_options(
&self,
input: DescribeAvailabilityOptionsRequest,
) -> RusotoFuture<DescribeAvailabilityOptionsResponse, DescribeAvailabilityOptionsError> {
let mut request = SignedRequest::new("POST", "cloudsearch", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeAvailabilityOptions");
params.put("Version", "2013-01-01");
DescribeAvailabilityOptionsRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeAvailabilityOptionsError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeAvailabilityOptionsResponse::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = try!(peek_at_name(&mut stack));
try!(start_element(&actual_tag_name, &mut stack));
result = try!(
DescribeAvailabilityOptionsResponseDeserializer::deserialize(
"DescribeAvailabilityOptionsResult",
&mut stack
)
);
skip_tree(&mut stack);
try!(end_element(&actual_tag_name, &mut stack));
}
Ok(result)
}))
})
}
fn describe_domains(
&self,
input: DescribeDomainsRequest,
) -> RusotoFuture<DescribeDomainsResponse, DescribeDomainsError> {
let mut request = SignedRequest::new("POST", "cloudsearch", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeDomains");
params.put("Version", "2013-01-01");
DescribeDomainsRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DescribeDomainsError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeDomainsResponse::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = try!(peek_at_name(&mut stack));
try!(start_element(&actual_tag_name, &mut stack));
result = try!(DescribeDomainsResponseDeserializer::deserialize(
"DescribeDomainsResult",
&mut stack
));
skip_tree(&mut stack);
try!(end_element(&actual_tag_name, &mut stack));
}
Ok(result)
}))
})
}
fn describe_expressions(
&self,
input: DescribeExpressionsRequest,
) -> RusotoFuture<DescribeExpressionsResponse, DescribeExpressionsError> {
let mut request = SignedRequest::new("POST", "cloudsearch", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeExpressions");
params.put("Version", "2013-01-01");
DescribeExpressionsRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response.buffer().from_err().and_then(|response| {
Err(DescribeExpressionsError::from_response(response))
}),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeExpressionsResponse::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = try!(peek_at_name(&mut stack));
try!(start_element(&actual_tag_name, &mut stack));
result = try!(DescribeExpressionsResponseDeserializer::deserialize(
"DescribeExpressionsResult",
&mut stack
));
skip_tree(&mut stack);
try!(end_element(&actual_tag_name, &mut stack));
}
Ok(result)
}))
})
}
fn describe_index_fields(
&self,
input: DescribeIndexFieldsRequest,
) -> RusotoFuture<DescribeIndexFieldsResponse, DescribeIndexFieldsError> {
let mut request = SignedRequest::new("POST", "cloudsearch", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeIndexFields");
params.put("Version", "2013-01-01");
DescribeIndexFieldsRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response.buffer().from_err().and_then(|response| {
Err(DescribeIndexFieldsError::from_response(response))
}),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeIndexFieldsResponse::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = try!(peek_at_name(&mut stack));
try!(start_element(&actual_tag_name, &mut stack));
result = try!(DescribeIndexFieldsResponseDeserializer::deserialize(
"DescribeIndexFieldsResult",
&mut stack
));
skip_tree(&mut stack);
try!(end_element(&actual_tag_name, &mut stack));
}
Ok(result)
}))
})
}
fn describe_scaling_parameters(
&self,
input: DescribeScalingParametersRequest,
) -> RusotoFuture<DescribeScalingParametersResponse, DescribeScalingParametersError> {
let mut request = SignedRequest::new("POST", "cloudsearch", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeScalingParameters");
params.put("Version", "2013-01-01");
DescribeScalingParametersRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeScalingParametersError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeScalingParametersResponse::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = try!(peek_at_name(&mut stack));
try!(start_element(&actual_tag_name, &mut stack));
result = try!(DescribeScalingParametersResponseDeserializer::deserialize(
"DescribeScalingParametersResult",
&mut stack
));
skip_tree(&mut stack);
try!(end_element(&actual_tag_name, &mut stack));
}
Ok(result)
}))
})
}
fn describe_service_access_policies(
&self,
input: DescribeServiceAccessPoliciesRequest,
) -> RusotoFuture<DescribeServiceAccessPoliciesResponse, DescribeServiceAccessPoliciesError>
{
let mut request = SignedRequest::new("POST", "cloudsearch", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeServiceAccessPolicies");
params.put("Version", "2013-01-01");
DescribeServiceAccessPoliciesRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeServiceAccessPoliciesError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeServiceAccessPoliciesResponse::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = try!(peek_at_name(&mut stack));
try!(start_element(&actual_tag_name, &mut stack));
result = try!(
DescribeServiceAccessPoliciesResponseDeserializer::deserialize(
"DescribeServiceAccessPoliciesResult",
&mut stack
)
);
skip_tree(&mut stack);
try!(end_element(&actual_tag_name, &mut stack));
}
Ok(result)
}))
})
}
fn describe_suggesters(
&self,
input: DescribeSuggestersRequest,
) -> RusotoFuture<DescribeSuggestersResponse, DescribeSuggestersError> {
let mut request = SignedRequest::new("POST", "cloudsearch", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeSuggesters");
params.put("Version", "2013-01-01");
DescribeSuggestersRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DescribeSuggestersError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeSuggestersResponse::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = try!(peek_at_name(&mut stack));
try!(start_element(&actual_tag_name, &mut stack));
result = try!(DescribeSuggestersResponseDeserializer::deserialize(
"DescribeSuggestersResult",
&mut stack
));
skip_tree(&mut stack);
try!(end_element(&actual_tag_name, &mut stack));
}
Ok(result)
}))
})
}
fn index_documents(
&self,
input: IndexDocumentsRequest,
) -> RusotoFuture<IndexDocumentsResponse, IndexDocumentsError> {
let mut request = SignedRequest::new("POST", "cloudsearch", &self.region, "/");
let mut params = Params::new();
params.put("Action", "IndexDocuments");
params.put("Version", "2013-01-01");
IndexDocumentsRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(IndexDocumentsError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = IndexDocumentsResponse::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = try!(peek_at_name(&mut stack));
try!(start_element(&actual_tag_name, &mut stack));
result = try!(IndexDocumentsResponseDeserializer::deserialize(
"IndexDocumentsResult",
&mut stack
));
skip_tree(&mut stack);
try!(end_element(&actual_tag_name, &mut stack));
}
Ok(result)
}))
})
}
fn list_domain_names(&self) -> RusotoFuture<ListDomainNamesResponse, ListDomainNamesError> {
let mut request = SignedRequest::new("POST", "cloudsearch", &self.region, "/");
let mut params = Params::new();
params.put("Action", "ListDomainNames");
params.put("Version", "2013-01-01");
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(ListDomainNamesError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = ListDomainNamesResponse::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = try!(peek_at_name(&mut stack));
try!(start_element(&actual_tag_name, &mut stack));
result = try!(ListDomainNamesResponseDeserializer::deserialize(
"ListDomainNamesResult",
&mut stack
));
skip_tree(&mut stack);
try!(end_element(&actual_tag_name, &mut stack));
}
Ok(result)
}))
})
}
fn update_availability_options(
&self,
input: UpdateAvailabilityOptionsRequest,
) -> RusotoFuture<UpdateAvailabilityOptionsResponse, UpdateAvailabilityOptionsError> {
let mut request = SignedRequest::new("POST", "cloudsearch", &self.region, "/");
let mut params = Params::new();
params.put("Action", "UpdateAvailabilityOptions");
params.put("Version", "2013-01-01");
UpdateAvailabilityOptionsRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(UpdateAvailabilityOptionsError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = UpdateAvailabilityOptionsResponse::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = try!(peek_at_name(&mut stack));
try!(start_element(&actual_tag_name, &mut stack));
result = try!(UpdateAvailabilityOptionsResponseDeserializer::deserialize(
"UpdateAvailabilityOptionsResult",
&mut stack
));
skip_tree(&mut stack);
try!(end_element(&actual_tag_name, &mut stack));
}
Ok(result)
}))
})
}
fn update_scaling_parameters(
&self,
input: UpdateScalingParametersRequest,
) -> RusotoFuture<UpdateScalingParametersResponse, UpdateScalingParametersError> {
let mut request = SignedRequest::new("POST", "cloudsearch", &self.region, "/");
let mut params = Params::new();
params.put("Action", "UpdateScalingParameters");
params.put("Version", "2013-01-01");
UpdateScalingParametersRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(UpdateScalingParametersError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = UpdateScalingParametersResponse::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = try!(peek_at_name(&mut stack));
try!(start_element(&actual_tag_name, &mut stack));
result = try!(UpdateScalingParametersResponseDeserializer::deserialize(
"UpdateScalingParametersResult",
&mut stack
));
skip_tree(&mut stack);
try!(end_element(&actual_tag_name, &mut stack));
}
Ok(result)
}))
})
}
fn update_service_access_policies(
&self,
input: UpdateServiceAccessPoliciesRequest,
) -> RusotoFuture<UpdateServiceAccessPoliciesResponse, UpdateServiceAccessPoliciesError> {
let mut request = SignedRequest::new("POST", "cloudsearch", &self.region, "/");
let mut params = Params::new();
params.put("Action", "UpdateServiceAccessPolicies");
params.put("Version", "2013-01-01");
UpdateServiceAccessPoliciesRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(UpdateServiceAccessPoliciesError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = UpdateServiceAccessPoliciesResponse::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = try!(peek_at_name(&mut stack));
try!(start_element(&actual_tag_name, &mut stack));
result = try!(
UpdateServiceAccessPoliciesResponseDeserializer::deserialize(
"UpdateServiceAccessPoliciesResult",
&mut stack
)
);
skip_tree(&mut stack);
try!(end_element(&actual_tag_name, &mut stack));
}
Ok(result)
}))
})
}
}
#[cfg(test)]
mod protocol_tests {}