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 std::io::Write;
use std::str::FromStr;
use xml;
use xml::reader::ParserConfig;
use xml::reader::XmlEvent;
use xml::EventReader;
use xml::EventWriter;
enum DeserializerNext {
Close,
Skip,
Element(String),
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct AccountLimit {
pub type_: String,
pub value: i64,
}
struct AccountLimitDeserializer;
impl AccountLimitDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<AccountLimit, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = AccountLimit::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[..] {
"Type" => {
obj.type_ = AccountLimitTypeDeserializer::deserialize("Type", stack)?;
}
"Value" => {
obj.value = LimitValueDeserializer::deserialize("Value", stack)?;
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct AccountLimitTypeDeserializer;
impl AccountLimitTypeDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
pub struct AccountLimitTypeSerializer;
impl AccountLimitTypeSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &String,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.to_string()
)))?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct AlarmIdentifier {
pub name: String,
pub region: String,
}
struct AlarmIdentifierDeserializer;
impl AlarmIdentifierDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<AlarmIdentifier, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = AlarmIdentifier::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[..] {
"Name" => {
obj.name = AlarmNameDeserializer::deserialize("Name", stack)?;
}
"Region" => {
obj.region = CloudWatchRegionDeserializer::deserialize("Region", stack)?;
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
pub struct AlarmIdentifierSerializer;
impl AlarmIdentifierSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &AlarmIdentifier,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
writer.write(xml::writer::XmlEvent::start_element("Name"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.name
)))?;
writer.write(xml::writer::XmlEvent::end_element())?;
writer.write(xml::writer::XmlEvent::start_element("Region"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.region
)))?;
writer.write(xml::writer::XmlEvent::end_element())?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
struct AlarmNameDeserializer;
impl AlarmNameDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
pub struct AlarmNameSerializer;
impl AlarmNameSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &String,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.to_string()
)))?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
struct AliasHealthEnabledDeserializer;
impl AliasHealthEnabledDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<bool, XmlParseError> {
start_element(tag_name, stack)?;
let obj = bool::from_str(characters(stack)?.as_ref()).unwrap();
end_element(tag_name, stack)?;
Ok(obj)
}
}
pub struct AliasHealthEnabledSerializer;
impl AliasHealthEnabledSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &bool,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.to_string()
)))?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct AliasTarget {
pub dns_name: String,
pub evaluate_target_health: bool,
pub hosted_zone_id: String,
}
struct AliasTargetDeserializer;
impl AliasTargetDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<AliasTarget, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = AliasTarget::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[..] {
"DNSName" => {
obj.dns_name = DNSNameDeserializer::deserialize("DNSName", stack)?;
}
"EvaluateTargetHealth" => {
obj.evaluate_target_health = AliasHealthEnabledDeserializer::deserialize(
"EvaluateTargetHealth",
stack,
)?;
}
"HostedZoneId" => {
obj.hosted_zone_id =
ResourceIdDeserializer::deserialize("HostedZoneId", stack)?;
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
pub struct AliasTargetSerializer;
impl AliasTargetSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &AliasTarget,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
writer.write(xml::writer::XmlEvent::start_element("DNSName"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.dns_name
)))?;
writer.write(xml::writer::XmlEvent::end_element())?;
writer.write(xml::writer::XmlEvent::start_element("EvaluateTargetHealth"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.evaluate_target_health
)))?;
writer.write(xml::writer::XmlEvent::end_element())?;
writer.write(xml::writer::XmlEvent::start_element("HostedZoneId"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.hosted_zone_id
)))?;
writer.write(xml::writer::XmlEvent::end_element())?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
pub struct AssociateVPCCommentSerializer;
impl AssociateVPCCommentSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &String,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.to_string()
)))?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct AssociateVPCWithHostedZoneRequest {
pub comment: Option<String>,
pub hosted_zone_id: String,
pub vpc: VPC,
}
pub struct AssociateVPCWithHostedZoneRequestSerializer;
impl AssociateVPCWithHostedZoneRequestSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &AssociateVPCWithHostedZoneRequest,
xmlns: &str,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name).default_ns(xmlns))?;
if let Some(ref value) = obj.comment {
&AssociateVPCCommentSerializer::serialize(&mut writer, "Comment", value)?;
}
VPCSerializer::serialize(&mut writer, "VPC", &obj.vpc)?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct AssociateVPCWithHostedZoneResponse {
pub change_info: ChangeInfo,
}
struct AssociateVPCWithHostedZoneResponseDeserializer;
impl AssociateVPCWithHostedZoneResponseDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<AssociateVPCWithHostedZoneResponse, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = AssociateVPCWithHostedZoneResponse::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[..] {
"ChangeInfo" => {
obj.change_info = ChangeInfoDeserializer::deserialize("ChangeInfo", stack)?;
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct Change {
pub action: String,
pub resource_record_set: ResourceRecordSet,
}
pub struct ChangeSerializer;
impl ChangeSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &Change,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
writer.write(xml::writer::XmlEvent::start_element("Action"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.action
)))?;
writer.write(xml::writer::XmlEvent::end_element())?;
ResourceRecordSetSerializer::serialize(
&mut writer,
"ResourceRecordSet",
&obj.resource_record_set,
)?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
pub struct ChangeActionSerializer;
impl ChangeActionSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &String,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.to_string()
)))?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ChangeBatch {
pub changes: Vec<Change>,
pub comment: Option<String>,
}
pub struct ChangeBatchSerializer;
impl ChangeBatchSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &ChangeBatch,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
ChangesSerializer::serialize(&mut writer, "Changes", &obj.changes)?;
if let Some(ref value) = obj.comment {
writer.write(xml::writer::XmlEvent::start_element("Comment"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = value
)));
writer.write(xml::writer::XmlEvent::end_element())?;
}
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ChangeInfo {
pub comment: Option<String>,
pub id: String,
pub status: String,
pub submitted_at: String,
}
struct ChangeInfoDeserializer;
impl ChangeInfoDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ChangeInfo, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = ChangeInfo::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[..] {
"Comment" => {
obj.comment = Some(ResourceDescriptionDeserializer::deserialize(
"Comment", stack,
)?);
}
"Id" => {
obj.id = ResourceIdDeserializer::deserialize("Id", stack)?;
}
"Status" => {
obj.status = ChangeStatusDeserializer::deserialize("Status", stack)?;
}
"SubmittedAt" => {
obj.submitted_at =
TimeStampDeserializer::deserialize("SubmittedAt", stack)?;
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ChangeResourceRecordSetsRequest {
pub change_batch: ChangeBatch,
pub hosted_zone_id: String,
}
pub struct ChangeResourceRecordSetsRequestSerializer;
impl ChangeResourceRecordSetsRequestSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &ChangeResourceRecordSetsRequest,
xmlns: &str,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name).default_ns(xmlns))?;
ChangeBatchSerializer::serialize(&mut writer, "ChangeBatch", &obj.change_batch)?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ChangeResourceRecordSetsResponse {
pub change_info: ChangeInfo,
}
struct ChangeResourceRecordSetsResponseDeserializer;
impl ChangeResourceRecordSetsResponseDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ChangeResourceRecordSetsResponse, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = ChangeResourceRecordSetsResponse::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[..] {
"ChangeInfo" => {
obj.change_info = ChangeInfoDeserializer::deserialize("ChangeInfo", stack)?;
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct ChangeStatusDeserializer;
impl ChangeStatusDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ChangeTagsForResourceRequest {
pub add_tags: Option<Vec<Tag>>,
pub remove_tag_keys: Option<Vec<String>>,
pub resource_id: String,
pub resource_type: String,
}
pub struct ChangeTagsForResourceRequestSerializer;
impl ChangeTagsForResourceRequestSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &ChangeTagsForResourceRequest,
xmlns: &str,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name).default_ns(xmlns))?;
if let Some(ref value) = obj.add_tags {
&TagListSerializer::serialize(&mut writer, "AddTags", value)?;
}
if let Some(ref value) = obj.remove_tag_keys {
&TagKeyListSerializer::serialize(&mut writer, "RemoveTagKeys", value)?;
}
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ChangeTagsForResourceResponse {}
struct ChangeTagsForResourceResponseDeserializer;
impl ChangeTagsForResourceResponseDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ChangeTagsForResourceResponse, XmlParseError> {
start_element(tag_name, stack)?;
let obj = ChangeTagsForResourceResponse::default();
end_element(tag_name, stack)?;
Ok(obj)
}
}
pub struct ChangesSerializer;
impl ChangesSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &Vec<Change>,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
for element in obj {
ChangeSerializer::serialize(writer, "Change", element)?;
}
writer.write(xml::writer::XmlEvent::end_element())?;
Ok(())
}
}
struct CheckerIpRangesDeserializer;
impl CheckerIpRangesDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<String>, XmlParseError> {
let mut obj = vec![];
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(IPAddressCidrDeserializer::deserialize("member", stack)?);
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
end_element(tag_name, stack)?;
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
struct ChildHealthCheckListDeserializer;
impl ChildHealthCheckListDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<String>, XmlParseError> {
let mut obj = vec![];
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 == "ChildHealthCheck" {
obj.push(HealthCheckIdDeserializer::deserialize(
"ChildHealthCheck",
stack,
)?);
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
end_element(tag_name, stack)?;
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
pub struct ChildHealthCheckListSerializer;
impl ChildHealthCheckListSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &Vec<String>,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
for element in obj {
HealthCheckIdSerializer::serialize(writer, "ChildHealthCheck", element)?;
}
writer.write(xml::writer::XmlEvent::end_element())?;
Ok(())
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CloudWatchAlarmConfiguration {
pub comparison_operator: String,
pub dimensions: Option<Vec<Dimension>>,
pub evaluation_periods: i64,
pub metric_name: String,
pub namespace: String,
pub period: i64,
pub statistic: String,
pub threshold: f64,
}
struct CloudWatchAlarmConfigurationDeserializer;
impl CloudWatchAlarmConfigurationDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CloudWatchAlarmConfiguration, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = CloudWatchAlarmConfiguration::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[..] {
"ComparisonOperator" => {
obj.comparison_operator = ComparisonOperatorDeserializer::deserialize(
"ComparisonOperator",
stack,
)?;
}
"Dimensions" => {
obj.dimensions = match obj.dimensions {
Some(ref mut existing) => {
existing.extend(DimensionListDeserializer::deserialize(
"Dimensions",
stack,
)?);
Some(existing.to_vec())
}
None => {
Some(DimensionListDeserializer::deserialize("Dimensions", stack)?)
}
};
}
"EvaluationPeriods" => {
obj.evaluation_periods =
EvaluationPeriodsDeserializer::deserialize("EvaluationPeriods", stack)?;
}
"MetricName" => {
obj.metric_name = MetricNameDeserializer::deserialize("MetricName", stack)?;
}
"Namespace" => {
obj.namespace = NamespaceDeserializer::deserialize("Namespace", stack)?;
}
"Period" => {
obj.period = PeriodDeserializer::deserialize("Period", stack)?;
}
"Statistic" => {
obj.statistic = StatisticDeserializer::deserialize("Statistic", stack)?;
}
"Threshold" => {
obj.threshold = ThresholdDeserializer::deserialize("Threshold", stack)?;
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct CloudWatchLogsLogGroupArnDeserializer;
impl CloudWatchLogsLogGroupArnDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
pub struct CloudWatchLogsLogGroupArnSerializer;
impl CloudWatchLogsLogGroupArnSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &String,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.to_string()
)))?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
struct CloudWatchRegionDeserializer;
impl CloudWatchRegionDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
pub struct CloudWatchRegionSerializer;
impl CloudWatchRegionSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &String,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.to_string()
)))?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
struct ComparisonOperatorDeserializer;
impl ComparisonOperatorDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateHealthCheckRequest {
pub caller_reference: String,
pub health_check_config: HealthCheckConfig,
}
pub struct CreateHealthCheckRequestSerializer;
impl CreateHealthCheckRequestSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &CreateHealthCheckRequest,
xmlns: &str,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name).default_ns(xmlns))?;
HealthCheckNonceSerializer::serialize(
&mut writer,
"CallerReference",
&obj.caller_reference,
)?;
HealthCheckConfigSerializer::serialize(
&mut writer,
"HealthCheckConfig",
&obj.health_check_config,
)?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateHealthCheckResponse {
pub health_check: HealthCheck,
pub location: String,
}
struct CreateHealthCheckResponseDeserializer;
impl CreateHealthCheckResponseDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CreateHealthCheckResponse, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = CreateHealthCheckResponse::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[..] {
"HealthCheck" => {
obj.health_check =
HealthCheckDeserializer::deserialize("HealthCheck", stack)?;
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateHostedZoneRequest {
pub caller_reference: String,
pub delegation_set_id: Option<String>,
pub hosted_zone_config: Option<HostedZoneConfig>,
pub name: String,
pub vpc: Option<VPC>,
}
pub struct CreateHostedZoneRequestSerializer;
impl CreateHostedZoneRequestSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &CreateHostedZoneRequest,
xmlns: &str,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name).default_ns(xmlns))?;
NonceSerializer::serialize(&mut writer, "CallerReference", &obj.caller_reference)?;
if let Some(ref value) = obj.delegation_set_id {
&ResourceIdSerializer::serialize(&mut writer, "DelegationSetId", value)?;
}
if let Some(ref value) = obj.hosted_zone_config {
&HostedZoneConfigSerializer::serialize(&mut writer, "HostedZoneConfig", value)?;
}
DNSNameSerializer::serialize(&mut writer, "Name", &obj.name)?;
if let Some(ref value) = obj.vpc {
&VPCSerializer::serialize(&mut writer, "VPC", value)?;
}
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateHostedZoneResponse {
pub change_info: ChangeInfo,
pub delegation_set: DelegationSet,
pub hosted_zone: HostedZone,
pub location: String,
pub vpc: Option<VPC>,
}
struct CreateHostedZoneResponseDeserializer;
impl CreateHostedZoneResponseDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CreateHostedZoneResponse, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = CreateHostedZoneResponse::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[..] {
"ChangeInfo" => {
obj.change_info = ChangeInfoDeserializer::deserialize("ChangeInfo", stack)?;
}
"DelegationSet" => {
obj.delegation_set =
DelegationSetDeserializer::deserialize("DelegationSet", stack)?;
}
"HostedZone" => {
obj.hosted_zone = HostedZoneDeserializer::deserialize("HostedZone", stack)?;
}
"VPC" => {
obj.vpc = Some(VPCDeserializer::deserialize("VPC", stack)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateQueryLoggingConfigRequest {
pub cloud_watch_logs_log_group_arn: String,
pub hosted_zone_id: String,
}
pub struct CreateQueryLoggingConfigRequestSerializer;
impl CreateQueryLoggingConfigRequestSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &CreateQueryLoggingConfigRequest,
xmlns: &str,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name).default_ns(xmlns))?;
CloudWatchLogsLogGroupArnSerializer::serialize(
&mut writer,
"CloudWatchLogsLogGroupArn",
&obj.cloud_watch_logs_log_group_arn,
)?;
ResourceIdSerializer::serialize(&mut writer, "HostedZoneId", &obj.hosted_zone_id)?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateQueryLoggingConfigResponse {
pub location: String,
pub query_logging_config: QueryLoggingConfig,
}
struct CreateQueryLoggingConfigResponseDeserializer;
impl CreateQueryLoggingConfigResponseDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CreateQueryLoggingConfigResponse, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = CreateQueryLoggingConfigResponse::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[..] {
"QueryLoggingConfig" => {
obj.query_logging_config = QueryLoggingConfigDeserializer::deserialize(
"QueryLoggingConfig",
stack,
)?;
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateReusableDelegationSetRequest {
pub caller_reference: String,
pub hosted_zone_id: Option<String>,
}
pub struct CreateReusableDelegationSetRequestSerializer;
impl CreateReusableDelegationSetRequestSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &CreateReusableDelegationSetRequest,
xmlns: &str,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name).default_ns(xmlns))?;
NonceSerializer::serialize(&mut writer, "CallerReference", &obj.caller_reference)?;
if let Some(ref value) = obj.hosted_zone_id {
&ResourceIdSerializer::serialize(&mut writer, "HostedZoneId", value)?;
}
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateReusableDelegationSetResponse {
pub delegation_set: DelegationSet,
pub location: String,
}
struct CreateReusableDelegationSetResponseDeserializer;
impl CreateReusableDelegationSetResponseDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CreateReusableDelegationSetResponse, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = CreateReusableDelegationSetResponse::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[..] {
"DelegationSet" => {
obj.delegation_set =
DelegationSetDeserializer::deserialize("DelegationSet", stack)?;
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateTrafficPolicyInstanceRequest {
pub hosted_zone_id: String,
pub name: String,
pub ttl: i64,
pub traffic_policy_id: String,
pub traffic_policy_version: i64,
}
pub struct CreateTrafficPolicyInstanceRequestSerializer;
impl CreateTrafficPolicyInstanceRequestSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &CreateTrafficPolicyInstanceRequest,
xmlns: &str,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name).default_ns(xmlns))?;
ResourceIdSerializer::serialize(&mut writer, "HostedZoneId", &obj.hosted_zone_id)?;
DNSNameSerializer::serialize(&mut writer, "Name", &obj.name)?;
TTLSerializer::serialize(&mut writer, "TTL", &obj.ttl)?;
TrafficPolicyIdSerializer::serialize(
&mut writer,
"TrafficPolicyId",
&obj.traffic_policy_id,
)?;
TrafficPolicyVersionSerializer::serialize(
&mut writer,
"TrafficPolicyVersion",
&obj.traffic_policy_version,
)?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateTrafficPolicyInstanceResponse {
pub location: String,
pub traffic_policy_instance: TrafficPolicyInstance,
}
struct CreateTrafficPolicyInstanceResponseDeserializer;
impl CreateTrafficPolicyInstanceResponseDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CreateTrafficPolicyInstanceResponse, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = CreateTrafficPolicyInstanceResponse::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[..] {
"TrafficPolicyInstance" => {
obj.traffic_policy_instance =
TrafficPolicyInstanceDeserializer::deserialize(
"TrafficPolicyInstance",
stack,
)?;
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateTrafficPolicyRequest {
pub comment: Option<String>,
pub document: String,
pub name: String,
}
pub struct CreateTrafficPolicyRequestSerializer;
impl CreateTrafficPolicyRequestSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &CreateTrafficPolicyRequest,
xmlns: &str,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name).default_ns(xmlns))?;
if let Some(ref value) = obj.comment {
&TrafficPolicyCommentSerializer::serialize(&mut writer, "Comment", value)?;
}
TrafficPolicyDocumentSerializer::serialize(&mut writer, "Document", &obj.document)?;
TrafficPolicyNameSerializer::serialize(&mut writer, "Name", &obj.name)?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateTrafficPolicyResponse {
pub location: String,
pub traffic_policy: TrafficPolicy,
}
struct CreateTrafficPolicyResponseDeserializer;
impl CreateTrafficPolicyResponseDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CreateTrafficPolicyResponse, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = CreateTrafficPolicyResponse::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[..] {
"TrafficPolicy" => {
obj.traffic_policy =
TrafficPolicyDeserializer::deserialize("TrafficPolicy", stack)?;
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateTrafficPolicyVersionRequest {
pub comment: Option<String>,
pub document: String,
pub id: String,
}
pub struct CreateTrafficPolicyVersionRequestSerializer;
impl CreateTrafficPolicyVersionRequestSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &CreateTrafficPolicyVersionRequest,
xmlns: &str,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name).default_ns(xmlns))?;
if let Some(ref value) = obj.comment {
&TrafficPolicyCommentSerializer::serialize(&mut writer, "Comment", value)?;
}
TrafficPolicyDocumentSerializer::serialize(&mut writer, "Document", &obj.document)?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateTrafficPolicyVersionResponse {
pub location: String,
pub traffic_policy: TrafficPolicy,
}
struct CreateTrafficPolicyVersionResponseDeserializer;
impl CreateTrafficPolicyVersionResponseDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CreateTrafficPolicyVersionResponse, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = CreateTrafficPolicyVersionResponse::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[..] {
"TrafficPolicy" => {
obj.traffic_policy =
TrafficPolicyDeserializer::deserialize("TrafficPolicy", stack)?;
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateVPCAssociationAuthorizationRequest {
pub hosted_zone_id: String,
pub vpc: VPC,
}
pub struct CreateVPCAssociationAuthorizationRequestSerializer;
impl CreateVPCAssociationAuthorizationRequestSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &CreateVPCAssociationAuthorizationRequest,
xmlns: &str,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name).default_ns(xmlns))?;
VPCSerializer::serialize(&mut writer, "VPC", &obj.vpc)?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateVPCAssociationAuthorizationResponse {
pub hosted_zone_id: String,
pub vpc: VPC,
}
struct CreateVPCAssociationAuthorizationResponseDeserializer;
impl CreateVPCAssociationAuthorizationResponseDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CreateVPCAssociationAuthorizationResponse, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = CreateVPCAssociationAuthorizationResponse::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[..] {
"HostedZoneId" => {
obj.hosted_zone_id =
ResourceIdDeserializer::deserialize("HostedZoneId", stack)?;
}
"VPC" => {
obj.vpc = VPCDeserializer::deserialize("VPC", stack)?;
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct DNSNameDeserializer;
impl DNSNameDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
pub struct DNSNameSerializer;
impl DNSNameSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &String,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.to_string()
)))?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
struct DNSRCodeDeserializer;
impl DNSRCodeDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DelegationSet {
pub caller_reference: Option<String>,
pub id: Option<String>,
pub name_servers: Vec<String>,
}
struct DelegationSetDeserializer;
impl DelegationSetDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DelegationSet, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = DelegationSet::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[..] {
"CallerReference" => {
obj.caller_reference =
Some(NonceDeserializer::deserialize("CallerReference", stack)?);
}
"Id" => {
obj.id = Some(ResourceIdDeserializer::deserialize("Id", stack)?);
}
"NameServers" => {
obj.name_servers
.extend(DelegationSetNameServersDeserializer::deserialize(
"NameServers",
stack,
)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct DelegationSetNameServersDeserializer;
impl DelegationSetNameServersDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<String>, XmlParseError> {
let mut obj = vec![];
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 == "NameServer" {
obj.push(DNSNameDeserializer::deserialize("NameServer", stack)?);
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
end_element(tag_name, stack)?;
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
struct DelegationSetsDeserializer;
impl DelegationSetsDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<DelegationSet>, XmlParseError> {
let mut obj = vec![];
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 == "DelegationSet" {
obj.push(DelegationSetDeserializer::deserialize(
"DelegationSet",
stack,
)?);
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
end_element(tag_name, stack)?;
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DeleteHealthCheckRequest {
pub health_check_id: String,
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DeleteHealthCheckResponse {}
struct DeleteHealthCheckResponseDeserializer;
impl DeleteHealthCheckResponseDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DeleteHealthCheckResponse, XmlParseError> {
start_element(tag_name, stack)?;
let obj = DeleteHealthCheckResponse::default();
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DeleteHostedZoneRequest {
pub id: String,
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DeleteHostedZoneResponse {
pub change_info: ChangeInfo,
}
struct DeleteHostedZoneResponseDeserializer;
impl DeleteHostedZoneResponseDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DeleteHostedZoneResponse, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = DeleteHostedZoneResponse::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[..] {
"ChangeInfo" => {
obj.change_info = ChangeInfoDeserializer::deserialize("ChangeInfo", stack)?;
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DeleteQueryLoggingConfigRequest {
pub id: String,
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DeleteQueryLoggingConfigResponse {}
struct DeleteQueryLoggingConfigResponseDeserializer;
impl DeleteQueryLoggingConfigResponseDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DeleteQueryLoggingConfigResponse, XmlParseError> {
start_element(tag_name, stack)?;
let obj = DeleteQueryLoggingConfigResponse::default();
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DeleteReusableDelegationSetRequest {
pub id: String,
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DeleteReusableDelegationSetResponse {}
struct DeleteReusableDelegationSetResponseDeserializer;
impl DeleteReusableDelegationSetResponseDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DeleteReusableDelegationSetResponse, XmlParseError> {
start_element(tag_name, stack)?;
let obj = DeleteReusableDelegationSetResponse::default();
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DeleteTrafficPolicyInstanceRequest {
pub id: String,
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DeleteTrafficPolicyInstanceResponse {}
struct DeleteTrafficPolicyInstanceResponseDeserializer;
impl DeleteTrafficPolicyInstanceResponseDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DeleteTrafficPolicyInstanceResponse, XmlParseError> {
start_element(tag_name, stack)?;
let obj = DeleteTrafficPolicyInstanceResponse::default();
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DeleteTrafficPolicyRequest {
pub id: String,
pub version: i64,
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DeleteTrafficPolicyResponse {}
struct DeleteTrafficPolicyResponseDeserializer;
impl DeleteTrafficPolicyResponseDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DeleteTrafficPolicyResponse, XmlParseError> {
start_element(tag_name, stack)?;
let obj = DeleteTrafficPolicyResponse::default();
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DeleteVPCAssociationAuthorizationRequest {
pub hosted_zone_id: String,
pub vpc: VPC,
}
pub struct DeleteVPCAssociationAuthorizationRequestSerializer;
impl DeleteVPCAssociationAuthorizationRequestSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &DeleteVPCAssociationAuthorizationRequest,
xmlns: &str,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name).default_ns(xmlns))?;
VPCSerializer::serialize(&mut writer, "VPC", &obj.vpc)?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DeleteVPCAssociationAuthorizationResponse {}
struct DeleteVPCAssociationAuthorizationResponseDeserializer;
impl DeleteVPCAssociationAuthorizationResponseDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DeleteVPCAssociationAuthorizationResponse, XmlParseError> {
start_element(tag_name, stack)?;
let obj = DeleteVPCAssociationAuthorizationResponse::default();
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct Dimension {
pub name: String,
pub value: String,
}
struct DimensionDeserializer;
impl DimensionDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Dimension, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = Dimension::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[..] {
"Name" => {
obj.name = DimensionFieldDeserializer::deserialize("Name", stack)?;
}
"Value" => {
obj.value = DimensionFieldDeserializer::deserialize("Value", stack)?;
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct DimensionFieldDeserializer;
impl DimensionFieldDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct DimensionListDeserializer;
impl DimensionListDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<Dimension>, XmlParseError> {
let mut obj = vec![];
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 == "Dimension" {
obj.push(DimensionDeserializer::deserialize("Dimension", stack)?);
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
end_element(tag_name, stack)?;
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
struct DisabledDeserializer;
impl DisabledDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<bool, XmlParseError> {
start_element(tag_name, stack)?;
let obj = bool::from_str(characters(stack)?.as_ref()).unwrap();
end_element(tag_name, stack)?;
Ok(obj)
}
}
pub struct DisabledSerializer;
impl DisabledSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &bool,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.to_string()
)))?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
pub struct DisassociateVPCCommentSerializer;
impl DisassociateVPCCommentSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &String,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.to_string()
)))?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DisassociateVPCFromHostedZoneRequest {
pub comment: Option<String>,
pub hosted_zone_id: String,
pub vpc: VPC,
}
pub struct DisassociateVPCFromHostedZoneRequestSerializer;
impl DisassociateVPCFromHostedZoneRequestSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &DisassociateVPCFromHostedZoneRequest,
xmlns: &str,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name).default_ns(xmlns))?;
if let Some(ref value) = obj.comment {
&DisassociateVPCCommentSerializer::serialize(&mut writer, "Comment", value)?;
}
VPCSerializer::serialize(&mut writer, "VPC", &obj.vpc)?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DisassociateVPCFromHostedZoneResponse {
pub change_info: ChangeInfo,
}
struct DisassociateVPCFromHostedZoneResponseDeserializer;
impl DisassociateVPCFromHostedZoneResponseDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DisassociateVPCFromHostedZoneResponse, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = DisassociateVPCFromHostedZoneResponse::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[..] {
"ChangeInfo" => {
obj.change_info = ChangeInfoDeserializer::deserialize("ChangeInfo", stack)?;
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct EnableSNIDeserializer;
impl EnableSNIDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<bool, XmlParseError> {
start_element(tag_name, stack)?;
let obj = bool::from_str(characters(stack)?.as_ref()).unwrap();
end_element(tag_name, stack)?;
Ok(obj)
}
}
pub struct EnableSNISerializer;
impl EnableSNISerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &bool,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.to_string()
)))?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
struct EvaluationPeriodsDeserializer;
impl EvaluationPeriodsDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<i64, XmlParseError> {
start_element(tag_name, stack)?;
let obj = i64::from_str(characters(stack)?.as_ref()).unwrap();
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct FailureThresholdDeserializer;
impl FailureThresholdDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<i64, XmlParseError> {
start_element(tag_name, stack)?;
let obj = i64::from_str(characters(stack)?.as_ref()).unwrap();
end_element(tag_name, stack)?;
Ok(obj)
}
}
pub struct FailureThresholdSerializer;
impl FailureThresholdSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &i64,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.to_string()
)))?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
struct FullyQualifiedDomainNameDeserializer;
impl FullyQualifiedDomainNameDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
pub struct FullyQualifiedDomainNameSerializer;
impl FullyQualifiedDomainNameSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &String,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.to_string()
)))?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct GeoLocation {
pub continent_code: Option<String>,
pub country_code: Option<String>,
pub subdivision_code: Option<String>,
}
struct GeoLocationDeserializer;
impl GeoLocationDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<GeoLocation, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = GeoLocation::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[..] {
"ContinentCode" => {
obj.continent_code =
Some(GeoLocationContinentCodeDeserializer::deserialize(
"ContinentCode",
stack,
)?);
}
"CountryCode" => {
obj.country_code = Some(GeoLocationCountryCodeDeserializer::deserialize(
"CountryCode",
stack,
)?);
}
"SubdivisionCode" => {
obj.subdivision_code =
Some(GeoLocationSubdivisionCodeDeserializer::deserialize(
"SubdivisionCode",
stack,
)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
pub struct GeoLocationSerializer;
impl GeoLocationSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &GeoLocation,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
if let Some(ref value) = obj.continent_code {
writer.write(xml::writer::XmlEvent::start_element("ContinentCode"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = value
)));
writer.write(xml::writer::XmlEvent::end_element())?;
}
if let Some(ref value) = obj.country_code {
writer.write(xml::writer::XmlEvent::start_element("CountryCode"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = value
)));
writer.write(xml::writer::XmlEvent::end_element())?;
}
if let Some(ref value) = obj.subdivision_code {
writer.write(xml::writer::XmlEvent::start_element("SubdivisionCode"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = value
)));
writer.write(xml::writer::XmlEvent::end_element())?;
}
writer.write(xml::writer::XmlEvent::end_element())
}
}
struct GeoLocationContinentCodeDeserializer;
impl GeoLocationContinentCodeDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
pub struct GeoLocationContinentCodeSerializer;
impl GeoLocationContinentCodeSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &String,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.to_string()
)))?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
struct GeoLocationContinentNameDeserializer;
impl GeoLocationContinentNameDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct GeoLocationCountryCodeDeserializer;
impl GeoLocationCountryCodeDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
pub struct GeoLocationCountryCodeSerializer;
impl GeoLocationCountryCodeSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &String,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.to_string()
)))?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
struct GeoLocationCountryNameDeserializer;
impl GeoLocationCountryNameDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct GeoLocationDetails {
pub continent_code: Option<String>,
pub continent_name: Option<String>,
pub country_code: Option<String>,
pub country_name: Option<String>,
pub subdivision_code: Option<String>,
pub subdivision_name: Option<String>,
}
struct GeoLocationDetailsDeserializer;
impl GeoLocationDetailsDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<GeoLocationDetails, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = GeoLocationDetails::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[..] {
"ContinentCode" => {
obj.continent_code =
Some(GeoLocationContinentCodeDeserializer::deserialize(
"ContinentCode",
stack,
)?);
}
"ContinentName" => {
obj.continent_name =
Some(GeoLocationContinentNameDeserializer::deserialize(
"ContinentName",
stack,
)?);
}
"CountryCode" => {
obj.country_code = Some(GeoLocationCountryCodeDeserializer::deserialize(
"CountryCode",
stack,
)?);
}
"CountryName" => {
obj.country_name = Some(GeoLocationCountryNameDeserializer::deserialize(
"CountryName",
stack,
)?);
}
"SubdivisionCode" => {
obj.subdivision_code =
Some(GeoLocationSubdivisionCodeDeserializer::deserialize(
"SubdivisionCode",
stack,
)?);
}
"SubdivisionName" => {
obj.subdivision_name =
Some(GeoLocationSubdivisionNameDeserializer::deserialize(
"SubdivisionName",
stack,
)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct GeoLocationDetailsListDeserializer;
impl GeoLocationDetailsListDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<GeoLocationDetails>, XmlParseError> {
let mut obj = vec![];
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 == "GeoLocationDetails" {
obj.push(GeoLocationDetailsDeserializer::deserialize(
"GeoLocationDetails",
stack,
)?);
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
end_element(tag_name, stack)?;
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
struct GeoLocationSubdivisionCodeDeserializer;
impl GeoLocationSubdivisionCodeDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
pub struct GeoLocationSubdivisionCodeSerializer;
impl GeoLocationSubdivisionCodeSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &String,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.to_string()
)))?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
struct GeoLocationSubdivisionNameDeserializer;
impl GeoLocationSubdivisionNameDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct GetAccountLimitRequest {
pub type_: String,
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct GetAccountLimitResponse {
pub count: i64,
pub limit: AccountLimit,
}
struct GetAccountLimitResponseDeserializer;
impl GetAccountLimitResponseDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<GetAccountLimitResponse, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = GetAccountLimitResponse::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[..] {
"Count" => {
obj.count = UsageCountDeserializer::deserialize("Count", stack)?;
}
"Limit" => {
obj.limit = AccountLimitDeserializer::deserialize("Limit", stack)?;
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct GetChangeRequest {
pub id: String,
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct GetChangeResponse {
pub change_info: ChangeInfo,
}
struct GetChangeResponseDeserializer;
impl GetChangeResponseDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<GetChangeResponse, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = GetChangeResponse::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[..] {
"ChangeInfo" => {
obj.change_info = ChangeInfoDeserializer::deserialize("ChangeInfo", stack)?;
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct GetCheckerIpRangesRequest {}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct GetCheckerIpRangesResponse {
pub checker_ip_ranges: Vec<String>,
}
struct GetCheckerIpRangesResponseDeserializer;
impl GetCheckerIpRangesResponseDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<GetCheckerIpRangesResponse, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = GetCheckerIpRangesResponse::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[..] {
"CheckerIpRanges" => {
obj.checker_ip_ranges
.extend(CheckerIpRangesDeserializer::deserialize(
"CheckerIpRanges",
stack,
)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct GetGeoLocationRequest {
pub continent_code: Option<String>,
pub country_code: Option<String>,
pub subdivision_code: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct GetGeoLocationResponse {
pub geo_location_details: GeoLocationDetails,
}
struct GetGeoLocationResponseDeserializer;
impl GetGeoLocationResponseDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<GetGeoLocationResponse, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = GetGeoLocationResponse::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[..] {
"GeoLocationDetails" => {
obj.geo_location_details = GeoLocationDetailsDeserializer::deserialize(
"GeoLocationDetails",
stack,
)?;
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct GetHealthCheckCountRequest {}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct GetHealthCheckCountResponse {
pub health_check_count: i64,
}
struct GetHealthCheckCountResponseDeserializer;
impl GetHealthCheckCountResponseDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<GetHealthCheckCountResponse, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = GetHealthCheckCountResponse::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[..] {
"HealthCheckCount" => {
obj.health_check_count =
HealthCheckCountDeserializer::deserialize("HealthCheckCount", stack)?;
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct GetHealthCheckLastFailureReasonRequest {
pub health_check_id: String,
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct GetHealthCheckLastFailureReasonResponse {
pub health_check_observations: Vec<HealthCheckObservation>,
}
struct GetHealthCheckLastFailureReasonResponseDeserializer;
impl GetHealthCheckLastFailureReasonResponseDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<GetHealthCheckLastFailureReasonResponse, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = GetHealthCheckLastFailureReasonResponse::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[..] {
"HealthCheckObservations" => {
obj.health_check_observations.extend(
HealthCheckObservationsDeserializer::deserialize(
"HealthCheckObservations",
stack,
)?,
);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct GetHealthCheckRequest {
pub health_check_id: String,
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct GetHealthCheckResponse {
pub health_check: HealthCheck,
}
struct GetHealthCheckResponseDeserializer;
impl GetHealthCheckResponseDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<GetHealthCheckResponse, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = GetHealthCheckResponse::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[..] {
"HealthCheck" => {
obj.health_check =
HealthCheckDeserializer::deserialize("HealthCheck", stack)?;
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct GetHealthCheckStatusRequest {
pub health_check_id: String,
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct GetHealthCheckStatusResponse {
pub health_check_observations: Vec<HealthCheckObservation>,
}
struct GetHealthCheckStatusResponseDeserializer;
impl GetHealthCheckStatusResponseDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<GetHealthCheckStatusResponse, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = GetHealthCheckStatusResponse::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[..] {
"HealthCheckObservations" => {
obj.health_check_observations.extend(
HealthCheckObservationsDeserializer::deserialize(
"HealthCheckObservations",
stack,
)?,
);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct GetHostedZoneCountRequest {}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct GetHostedZoneCountResponse {
pub hosted_zone_count: i64,
}
struct GetHostedZoneCountResponseDeserializer;
impl GetHostedZoneCountResponseDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<GetHostedZoneCountResponse, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = GetHostedZoneCountResponse::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[..] {
"HostedZoneCount" => {
obj.hosted_zone_count =
HostedZoneCountDeserializer::deserialize("HostedZoneCount", stack)?;
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct GetHostedZoneLimitRequest {
pub hosted_zone_id: String,
pub type_: String,
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct GetHostedZoneLimitResponse {
pub count: i64,
pub limit: HostedZoneLimit,
}
struct GetHostedZoneLimitResponseDeserializer;
impl GetHostedZoneLimitResponseDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<GetHostedZoneLimitResponse, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = GetHostedZoneLimitResponse::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[..] {
"Count" => {
obj.count = UsageCountDeserializer::deserialize("Count", stack)?;
}
"Limit" => {
obj.limit = HostedZoneLimitDeserializer::deserialize("Limit", stack)?;
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct GetHostedZoneRequest {
pub id: String,
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct GetHostedZoneResponse {
pub delegation_set: Option<DelegationSet>,
pub hosted_zone: HostedZone,
pub vp_cs: Option<Vec<VPC>>,
}
struct GetHostedZoneResponseDeserializer;
impl GetHostedZoneResponseDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<GetHostedZoneResponse, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = GetHostedZoneResponse::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[..] {
"DelegationSet" => {
obj.delegation_set = Some(DelegationSetDeserializer::deserialize(
"DelegationSet",
stack,
)?);
}
"HostedZone" => {
obj.hosted_zone = HostedZoneDeserializer::deserialize("HostedZone", stack)?;
}
"VPCs" => {
obj.vp_cs = match obj.vp_cs {
Some(ref mut existing) => {
existing.extend(VPCsDeserializer::deserialize("VPCs", stack)?);
Some(existing.to_vec())
}
None => Some(VPCsDeserializer::deserialize("VPCs", stack)?),
};
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct GetQueryLoggingConfigRequest {
pub id: String,
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct GetQueryLoggingConfigResponse {
pub query_logging_config: QueryLoggingConfig,
}
struct GetQueryLoggingConfigResponseDeserializer;
impl GetQueryLoggingConfigResponseDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<GetQueryLoggingConfigResponse, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = GetQueryLoggingConfigResponse::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[..] {
"QueryLoggingConfig" => {
obj.query_logging_config = QueryLoggingConfigDeserializer::deserialize(
"QueryLoggingConfig",
stack,
)?;
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct GetReusableDelegationSetLimitRequest {
pub delegation_set_id: String,
pub type_: String,
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct GetReusableDelegationSetLimitResponse {
pub count: i64,
pub limit: ReusableDelegationSetLimit,
}
struct GetReusableDelegationSetLimitResponseDeserializer;
impl GetReusableDelegationSetLimitResponseDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<GetReusableDelegationSetLimitResponse, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = GetReusableDelegationSetLimitResponse::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[..] {
"Count" => {
obj.count = UsageCountDeserializer::deserialize("Count", stack)?;
}
"Limit" => {
obj.limit =
ReusableDelegationSetLimitDeserializer::deserialize("Limit", stack)?;
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct GetReusableDelegationSetRequest {
pub id: String,
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct GetReusableDelegationSetResponse {
pub delegation_set: DelegationSet,
}
struct GetReusableDelegationSetResponseDeserializer;
impl GetReusableDelegationSetResponseDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<GetReusableDelegationSetResponse, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = GetReusableDelegationSetResponse::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[..] {
"DelegationSet" => {
obj.delegation_set =
DelegationSetDeserializer::deserialize("DelegationSet", stack)?;
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct GetTrafficPolicyInstanceCountRequest {}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct GetTrafficPolicyInstanceCountResponse {
pub traffic_policy_instance_count: i64,
}
struct GetTrafficPolicyInstanceCountResponseDeserializer;
impl GetTrafficPolicyInstanceCountResponseDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<GetTrafficPolicyInstanceCountResponse, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = GetTrafficPolicyInstanceCountResponse::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[..] {
"TrafficPolicyInstanceCount" => {
obj.traffic_policy_instance_count =
TrafficPolicyInstanceCountDeserializer::deserialize(
"TrafficPolicyInstanceCount",
stack,
)?;
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct GetTrafficPolicyInstanceRequest {
pub id: String,
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct GetTrafficPolicyInstanceResponse {
pub traffic_policy_instance: TrafficPolicyInstance,
}
struct GetTrafficPolicyInstanceResponseDeserializer;
impl GetTrafficPolicyInstanceResponseDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<GetTrafficPolicyInstanceResponse, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = GetTrafficPolicyInstanceResponse::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[..] {
"TrafficPolicyInstance" => {
obj.traffic_policy_instance =
TrafficPolicyInstanceDeserializer::deserialize(
"TrafficPolicyInstance",
stack,
)?;
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct GetTrafficPolicyRequest {
pub id: String,
pub version: i64,
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct GetTrafficPolicyResponse {
pub traffic_policy: TrafficPolicy,
}
struct GetTrafficPolicyResponseDeserializer;
impl GetTrafficPolicyResponseDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<GetTrafficPolicyResponse, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = GetTrafficPolicyResponse::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[..] {
"TrafficPolicy" => {
obj.traffic_policy =
TrafficPolicyDeserializer::deserialize("TrafficPolicy", stack)?;
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct HealthCheck {
pub caller_reference: String,
pub cloud_watch_alarm_configuration: Option<CloudWatchAlarmConfiguration>,
pub health_check_config: HealthCheckConfig,
pub health_check_version: i64,
pub id: String,
pub linked_service: Option<LinkedService>,
}
struct HealthCheckDeserializer;
impl HealthCheckDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<HealthCheck, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = HealthCheck::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[..] {
"CallerReference" => {
obj.caller_reference =
HealthCheckNonceDeserializer::deserialize("CallerReference", stack)?;
}
"CloudWatchAlarmConfiguration" => {
obj.cloud_watch_alarm_configuration =
Some(CloudWatchAlarmConfigurationDeserializer::deserialize(
"CloudWatchAlarmConfiguration",
stack,
)?);
}
"HealthCheckConfig" => {
obj.health_check_config =
HealthCheckConfigDeserializer::deserialize("HealthCheckConfig", stack)?;
}
"HealthCheckVersion" => {
obj.health_check_version = HealthCheckVersionDeserializer::deserialize(
"HealthCheckVersion",
stack,
)?;
}
"Id" => {
obj.id = HealthCheckIdDeserializer::deserialize("Id", stack)?;
}
"LinkedService" => {
obj.linked_service = Some(LinkedServiceDeserializer::deserialize(
"LinkedService",
stack,
)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct HealthCheckConfig {
pub alarm_identifier: Option<AlarmIdentifier>,
pub child_health_checks: Option<Vec<String>>,
pub disabled: Option<bool>,
pub enable_sni: Option<bool>,
pub failure_threshold: Option<i64>,
pub fully_qualified_domain_name: Option<String>,
pub health_threshold: Option<i64>,
pub ip_address: Option<String>,
pub insufficient_data_health_status: Option<String>,
pub inverted: Option<bool>,
pub measure_latency: Option<bool>,
pub port: Option<i64>,
pub regions: Option<Vec<String>>,
pub request_interval: Option<i64>,
pub resource_path: Option<String>,
pub search_string: Option<String>,
pub type_: String,
}
struct HealthCheckConfigDeserializer;
impl HealthCheckConfigDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<HealthCheckConfig, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = HealthCheckConfig::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[..] {
"AlarmIdentifier" => {
obj.alarm_identifier = Some(AlarmIdentifierDeserializer::deserialize(
"AlarmIdentifier",
stack,
)?);
}
"ChildHealthChecks" => {
obj.child_health_checks = match obj.child_health_checks {
Some(ref mut existing) => {
existing.extend(ChildHealthCheckListDeserializer::deserialize(
"ChildHealthChecks",
stack,
)?);
Some(existing.to_vec())
}
None => Some(ChildHealthCheckListDeserializer::deserialize(
"ChildHealthChecks",
stack,
)?),
};
}
"Disabled" => {
obj.disabled = Some(DisabledDeserializer::deserialize("Disabled", stack)?);
}
"EnableSNI" => {
obj.enable_sni =
Some(EnableSNIDeserializer::deserialize("EnableSNI", stack)?);
}
"FailureThreshold" => {
obj.failure_threshold = Some(FailureThresholdDeserializer::deserialize(
"FailureThreshold",
stack,
)?);
}
"FullyQualifiedDomainName" => {
obj.fully_qualified_domain_name =
Some(FullyQualifiedDomainNameDeserializer::deserialize(
"FullyQualifiedDomainName",
stack,
)?);
}
"HealthThreshold" => {
obj.health_threshold = Some(HealthThresholdDeserializer::deserialize(
"HealthThreshold",
stack,
)?);
}
"IPAddress" => {
obj.ip_address =
Some(IPAddressDeserializer::deserialize("IPAddress", stack)?);
}
"InsufficientDataHealthStatus" => {
obj.insufficient_data_health_status =
Some(InsufficientDataHealthStatusDeserializer::deserialize(
"InsufficientDataHealthStatus",
stack,
)?);
}
"Inverted" => {
obj.inverted = Some(InvertedDeserializer::deserialize("Inverted", stack)?);
}
"MeasureLatency" => {
obj.measure_latency = Some(MeasureLatencyDeserializer::deserialize(
"MeasureLatency",
stack,
)?);
}
"Port" => {
obj.port = Some(PortDeserializer::deserialize("Port", stack)?);
}
"Regions" => {
obj.regions = match obj.regions {
Some(ref mut existing) => {
existing.extend(HealthCheckRegionListDeserializer::deserialize(
"Regions", stack,
)?);
Some(existing.to_vec())
}
None => Some(HealthCheckRegionListDeserializer::deserialize(
"Regions", stack,
)?),
};
}
"RequestInterval" => {
obj.request_interval = Some(RequestIntervalDeserializer::deserialize(
"RequestInterval",
stack,
)?);
}
"ResourcePath" => {
obj.resource_path = Some(ResourcePathDeserializer::deserialize(
"ResourcePath",
stack,
)?);
}
"SearchString" => {
obj.search_string = Some(SearchStringDeserializer::deserialize(
"SearchString",
stack,
)?);
}
"Type" => {
obj.type_ = HealthCheckTypeDeserializer::deserialize("Type", stack)?;
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
pub struct HealthCheckConfigSerializer;
impl HealthCheckConfigSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &HealthCheckConfig,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
if let Some(ref value) = obj.alarm_identifier {
&AlarmIdentifierSerializer::serialize(&mut writer, "AlarmIdentifier", value)?;
}
if let Some(ref value) = obj.child_health_checks {
&ChildHealthCheckListSerializer::serialize(&mut writer, "ChildHealthChecks", value)?;
}
if let Some(ref value) = obj.disabled {
writer.write(xml::writer::XmlEvent::start_element("Disabled"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = value
)));
writer.write(xml::writer::XmlEvent::end_element())?;
}
if let Some(ref value) = obj.enable_sni {
writer.write(xml::writer::XmlEvent::start_element("EnableSNI"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = value
)));
writer.write(xml::writer::XmlEvent::end_element())?;
}
if let Some(ref value) = obj.failure_threshold {
writer.write(xml::writer::XmlEvent::start_element("FailureThreshold"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = value
)));
writer.write(xml::writer::XmlEvent::end_element())?;
}
if let Some(ref value) = obj.fully_qualified_domain_name {
writer.write(xml::writer::XmlEvent::start_element(
"FullyQualifiedDomainName",
))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = value
)));
writer.write(xml::writer::XmlEvent::end_element())?;
}
if let Some(ref value) = obj.health_threshold {
writer.write(xml::writer::XmlEvent::start_element("HealthThreshold"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = value
)));
writer.write(xml::writer::XmlEvent::end_element())?;
}
if let Some(ref value) = obj.ip_address {
writer.write(xml::writer::XmlEvent::start_element("IPAddress"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = value
)));
writer.write(xml::writer::XmlEvent::end_element())?;
}
if let Some(ref value) = obj.insufficient_data_health_status {
writer.write(xml::writer::XmlEvent::start_element(
"InsufficientDataHealthStatus",
))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = value
)));
writer.write(xml::writer::XmlEvent::end_element())?;
}
if let Some(ref value) = obj.inverted {
writer.write(xml::writer::XmlEvent::start_element("Inverted"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = value
)));
writer.write(xml::writer::XmlEvent::end_element())?;
}
if let Some(ref value) = obj.measure_latency {
writer.write(xml::writer::XmlEvent::start_element("MeasureLatency"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = value
)));
writer.write(xml::writer::XmlEvent::end_element())?;
}
if let Some(ref value) = obj.port {
writer.write(xml::writer::XmlEvent::start_element("Port"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = value
)));
writer.write(xml::writer::XmlEvent::end_element())?;
}
if let Some(ref value) = obj.regions {
&HealthCheckRegionListSerializer::serialize(&mut writer, "Regions", value)?;
}
if let Some(ref value) = obj.request_interval {
writer.write(xml::writer::XmlEvent::start_element("RequestInterval"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = value
)));
writer.write(xml::writer::XmlEvent::end_element())?;
}
if let Some(ref value) = obj.resource_path {
writer.write(xml::writer::XmlEvent::start_element("ResourcePath"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = value
)));
writer.write(xml::writer::XmlEvent::end_element())?;
}
if let Some(ref value) = obj.search_string {
writer.write(xml::writer::XmlEvent::start_element("SearchString"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = value
)));
writer.write(xml::writer::XmlEvent::end_element())?;
}
writer.write(xml::writer::XmlEvent::start_element("Type"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.type_
)))?;
writer.write(xml::writer::XmlEvent::end_element())?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
struct HealthCheckCountDeserializer;
impl HealthCheckCountDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<i64, XmlParseError> {
start_element(tag_name, stack)?;
let obj = i64::from_str(characters(stack)?.as_ref()).unwrap();
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct HealthCheckIdDeserializer;
impl HealthCheckIdDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
pub struct HealthCheckIdSerializer;
impl HealthCheckIdSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &String,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.to_string()
)))?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
struct HealthCheckNonceDeserializer;
impl HealthCheckNonceDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
pub struct HealthCheckNonceSerializer;
impl HealthCheckNonceSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &String,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.to_string()
)))?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct HealthCheckObservation {
pub ip_address: Option<String>,
pub region: Option<String>,
pub status_report: Option<StatusReport>,
}
struct HealthCheckObservationDeserializer;
impl HealthCheckObservationDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<HealthCheckObservation, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = HealthCheckObservation::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[..] {
"IPAddress" => {
obj.ip_address =
Some(IPAddressDeserializer::deserialize("IPAddress", stack)?);
}
"Region" => {
obj.region =
Some(HealthCheckRegionDeserializer::deserialize("Region", stack)?);
}
"StatusReport" => {
obj.status_report = Some(StatusReportDeserializer::deserialize(
"StatusReport",
stack,
)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct HealthCheckObservationsDeserializer;
impl HealthCheckObservationsDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<HealthCheckObservation>, XmlParseError> {
let mut obj = vec![];
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 == "HealthCheckObservation" {
obj.push(HealthCheckObservationDeserializer::deserialize(
"HealthCheckObservation",
stack,
)?);
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
end_element(tag_name, stack)?;
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
struct HealthCheckRegionDeserializer;
impl HealthCheckRegionDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
pub struct HealthCheckRegionSerializer;
impl HealthCheckRegionSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &String,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.to_string()
)))?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
struct HealthCheckRegionListDeserializer;
impl HealthCheckRegionListDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<String>, XmlParseError> {
let mut obj = vec![];
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 == "Region" {
obj.push(HealthCheckRegionDeserializer::deserialize("Region", stack)?);
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
end_element(tag_name, stack)?;
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
pub struct HealthCheckRegionListSerializer;
impl HealthCheckRegionListSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &Vec<String>,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
for element in obj {
HealthCheckRegionSerializer::serialize(writer, "Region", element)?;
}
writer.write(xml::writer::XmlEvent::end_element())?;
Ok(())
}
}
struct HealthCheckTypeDeserializer;
impl HealthCheckTypeDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
pub struct HealthCheckTypeSerializer;
impl HealthCheckTypeSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &String,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.to_string()
)))?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
struct HealthCheckVersionDeserializer;
impl HealthCheckVersionDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<i64, XmlParseError> {
start_element(tag_name, stack)?;
let obj = i64::from_str(characters(stack)?.as_ref()).unwrap();
end_element(tag_name, stack)?;
Ok(obj)
}
}
pub struct HealthCheckVersionSerializer;
impl HealthCheckVersionSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &i64,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.to_string()
)))?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
struct HealthChecksDeserializer;
impl HealthChecksDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<HealthCheck>, XmlParseError> {
let mut obj = vec![];
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 == "HealthCheck" {
obj.push(HealthCheckDeserializer::deserialize("HealthCheck", stack)?);
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
end_element(tag_name, stack)?;
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
struct HealthThresholdDeserializer;
impl HealthThresholdDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<i64, XmlParseError> {
start_element(tag_name, stack)?;
let obj = i64::from_str(characters(stack)?.as_ref()).unwrap();
end_element(tag_name, stack)?;
Ok(obj)
}
}
pub struct HealthThresholdSerializer;
impl HealthThresholdSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &i64,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.to_string()
)))?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct HostedZone {
pub caller_reference: String,
pub config: Option<HostedZoneConfig>,
pub id: String,
pub linked_service: Option<LinkedService>,
pub name: String,
pub resource_record_set_count: Option<i64>,
}
struct HostedZoneDeserializer;
impl HostedZoneDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<HostedZone, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = HostedZone::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[..] {
"CallerReference" => {
obj.caller_reference =
NonceDeserializer::deserialize("CallerReference", stack)?;
}
"Config" => {
obj.config =
Some(HostedZoneConfigDeserializer::deserialize("Config", stack)?);
}
"Id" => {
obj.id = ResourceIdDeserializer::deserialize("Id", stack)?;
}
"LinkedService" => {
obj.linked_service = Some(LinkedServiceDeserializer::deserialize(
"LinkedService",
stack,
)?);
}
"Name" => {
obj.name = DNSNameDeserializer::deserialize("Name", stack)?;
}
"ResourceRecordSetCount" => {
obj.resource_record_set_count =
Some(HostedZoneRRSetCountDeserializer::deserialize(
"ResourceRecordSetCount",
stack,
)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct HostedZoneConfig {
pub comment: Option<String>,
pub private_zone: Option<bool>,
}
struct HostedZoneConfigDeserializer;
impl HostedZoneConfigDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<HostedZoneConfig, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = HostedZoneConfig::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[..] {
"Comment" => {
obj.comment = Some(ResourceDescriptionDeserializer::deserialize(
"Comment", stack,
)?);
}
"PrivateZone" => {
obj.private_zone = Some(IsPrivateZoneDeserializer::deserialize(
"PrivateZone",
stack,
)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
pub struct HostedZoneConfigSerializer;
impl HostedZoneConfigSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &HostedZoneConfig,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
if let Some(ref value) = obj.comment {
writer.write(xml::writer::XmlEvent::start_element("Comment"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = value
)));
writer.write(xml::writer::XmlEvent::end_element())?;
}
if let Some(ref value) = obj.private_zone {
writer.write(xml::writer::XmlEvent::start_element("PrivateZone"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = value
)));
writer.write(xml::writer::XmlEvent::end_element())?;
}
writer.write(xml::writer::XmlEvent::end_element())
}
}
struct HostedZoneCountDeserializer;
impl HostedZoneCountDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<i64, XmlParseError> {
start_element(tag_name, stack)?;
let obj = i64::from_str(characters(stack)?.as_ref()).unwrap();
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct HostedZoneLimit {
pub type_: String,
pub value: i64,
}
struct HostedZoneLimitDeserializer;
impl HostedZoneLimitDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<HostedZoneLimit, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = HostedZoneLimit::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[..] {
"Type" => {
obj.type_ = HostedZoneLimitTypeDeserializer::deserialize("Type", stack)?;
}
"Value" => {
obj.value = LimitValueDeserializer::deserialize("Value", stack)?;
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct HostedZoneLimitTypeDeserializer;
impl HostedZoneLimitTypeDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
pub struct HostedZoneLimitTypeSerializer;
impl HostedZoneLimitTypeSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &String,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.to_string()
)))?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
struct HostedZoneRRSetCountDeserializer;
impl HostedZoneRRSetCountDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<i64, XmlParseError> {
start_element(tag_name, stack)?;
let obj = i64::from_str(characters(stack)?.as_ref()).unwrap();
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct HostedZonesDeserializer;
impl HostedZonesDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<HostedZone>, XmlParseError> {
let mut obj = vec![];
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 == "HostedZone" {
obj.push(HostedZoneDeserializer::deserialize("HostedZone", stack)?);
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
end_element(tag_name, stack)?;
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
struct IPAddressDeserializer;
impl IPAddressDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
pub struct IPAddressSerializer;
impl IPAddressSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &String,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.to_string()
)))?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
struct IPAddressCidrDeserializer;
impl IPAddressCidrDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct InsufficientDataHealthStatusDeserializer;
impl InsufficientDataHealthStatusDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
pub struct InsufficientDataHealthStatusSerializer;
impl InsufficientDataHealthStatusSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &String,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.to_string()
)))?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
struct InvertedDeserializer;
impl InvertedDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<bool, XmlParseError> {
start_element(tag_name, stack)?;
let obj = bool::from_str(characters(stack)?.as_ref()).unwrap();
end_element(tag_name, stack)?;
Ok(obj)
}
}
pub struct InvertedSerializer;
impl InvertedSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &bool,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.to_string()
)))?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
struct IsPrivateZoneDeserializer;
impl IsPrivateZoneDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<bool, XmlParseError> {
start_element(tag_name, stack)?;
let obj = bool::from_str(characters(stack)?.as_ref()).unwrap();
end_element(tag_name, stack)?;
Ok(obj)
}
}
pub struct IsPrivateZoneSerializer;
impl IsPrivateZoneSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &bool,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.to_string()
)))?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
struct LimitValueDeserializer;
impl LimitValueDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<i64, XmlParseError> {
start_element(tag_name, stack)?;
let obj = i64::from_str(characters(stack)?.as_ref()).unwrap();
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct LinkedService {
pub description: Option<String>,
pub service_principal: Option<String>,
}
struct LinkedServiceDeserializer;
impl LinkedServiceDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<LinkedService, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = LinkedService::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[..] {
"Description" => {
obj.description = Some(ResourceDescriptionDeserializer::deserialize(
"Description",
stack,
)?);
}
"ServicePrincipal" => {
obj.service_principal = Some(ServicePrincipalDeserializer::deserialize(
"ServicePrincipal",
stack,
)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ListGeoLocationsRequest {
pub max_items: Option<String>,
pub start_continent_code: Option<String>,
pub start_country_code: Option<String>,
pub start_subdivision_code: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ListGeoLocationsResponse {
pub geo_location_details_list: Vec<GeoLocationDetails>,
pub is_truncated: bool,
pub max_items: String,
pub next_continent_code: Option<String>,
pub next_country_code: Option<String>,
pub next_subdivision_code: Option<String>,
}
struct ListGeoLocationsResponseDeserializer;
impl ListGeoLocationsResponseDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ListGeoLocationsResponse, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = ListGeoLocationsResponse::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[..] {
"GeoLocationDetailsList" => {
obj.geo_location_details_list.extend(
GeoLocationDetailsListDeserializer::deserialize(
"GeoLocationDetailsList",
stack,
)?,
);
}
"IsTruncated" => {
obj.is_truncated =
PageTruncatedDeserializer::deserialize("IsTruncated", stack)?;
}
"MaxItems" => {
obj.max_items = PageMaxItemsDeserializer::deserialize("MaxItems", stack)?;
}
"NextContinentCode" => {
obj.next_continent_code =
Some(GeoLocationContinentCodeDeserializer::deserialize(
"NextContinentCode",
stack,
)?);
}
"NextCountryCode" => {
obj.next_country_code =
Some(GeoLocationCountryCodeDeserializer::deserialize(
"NextCountryCode",
stack,
)?);
}
"NextSubdivisionCode" => {
obj.next_subdivision_code =
Some(GeoLocationSubdivisionCodeDeserializer::deserialize(
"NextSubdivisionCode",
stack,
)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ListHealthChecksRequest {
pub marker: Option<String>,
pub max_items: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ListHealthChecksResponse {
pub health_checks: Vec<HealthCheck>,
pub is_truncated: bool,
pub marker: String,
pub max_items: String,
pub next_marker: Option<String>,
}
struct ListHealthChecksResponseDeserializer;
impl ListHealthChecksResponseDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ListHealthChecksResponse, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = ListHealthChecksResponse::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[..] {
"HealthChecks" => {
obj.health_checks
.extend(HealthChecksDeserializer::deserialize(
"HealthChecks",
stack,
)?);
}
"IsTruncated" => {
obj.is_truncated =
PageTruncatedDeserializer::deserialize("IsTruncated", stack)?;
}
"Marker" => {
obj.marker = PageMarkerDeserializer::deserialize("Marker", stack)?;
}
"MaxItems" => {
obj.max_items = PageMaxItemsDeserializer::deserialize("MaxItems", stack)?;
}
"NextMarker" => {
obj.next_marker =
Some(PageMarkerDeserializer::deserialize("NextMarker", stack)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ListHostedZonesByNameRequest {
pub dns_name: Option<String>,
pub hosted_zone_id: Option<String>,
pub max_items: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ListHostedZonesByNameResponse {
pub dns_name: Option<String>,
pub hosted_zone_id: Option<String>,
pub hosted_zones: Vec<HostedZone>,
pub is_truncated: bool,
pub max_items: String,
pub next_dns_name: Option<String>,
pub next_hosted_zone_id: Option<String>,
}
struct ListHostedZonesByNameResponseDeserializer;
impl ListHostedZonesByNameResponseDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ListHostedZonesByNameResponse, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = ListHostedZonesByNameResponse::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[..] {
"DNSName" => {
obj.dns_name = Some(DNSNameDeserializer::deserialize("DNSName", stack)?);
}
"HostedZoneId" => {
obj.hosted_zone_id =
Some(ResourceIdDeserializer::deserialize("HostedZoneId", stack)?);
}
"HostedZones" => {
obj.hosted_zones
.extend(HostedZonesDeserializer::deserialize("HostedZones", stack)?);
}
"IsTruncated" => {
obj.is_truncated =
PageTruncatedDeserializer::deserialize("IsTruncated", stack)?;
}
"MaxItems" => {
obj.max_items = PageMaxItemsDeserializer::deserialize("MaxItems", stack)?;
}
"NextDNSName" => {
obj.next_dns_name =
Some(DNSNameDeserializer::deserialize("NextDNSName", stack)?);
}
"NextHostedZoneId" => {
obj.next_hosted_zone_id = Some(ResourceIdDeserializer::deserialize(
"NextHostedZoneId",
stack,
)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ListHostedZonesRequest {
pub delegation_set_id: Option<String>,
pub marker: Option<String>,
pub max_items: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ListHostedZonesResponse {
pub hosted_zones: Vec<HostedZone>,
pub is_truncated: bool,
pub marker: String,
pub max_items: String,
pub next_marker: Option<String>,
}
struct ListHostedZonesResponseDeserializer;
impl ListHostedZonesResponseDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ListHostedZonesResponse, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = ListHostedZonesResponse::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[..] {
"HostedZones" => {
obj.hosted_zones
.extend(HostedZonesDeserializer::deserialize("HostedZones", stack)?);
}
"IsTruncated" => {
obj.is_truncated =
PageTruncatedDeserializer::deserialize("IsTruncated", stack)?;
}
"Marker" => {
obj.marker = PageMarkerDeserializer::deserialize("Marker", stack)?;
}
"MaxItems" => {
obj.max_items = PageMaxItemsDeserializer::deserialize("MaxItems", stack)?;
}
"NextMarker" => {
obj.next_marker =
Some(PageMarkerDeserializer::deserialize("NextMarker", stack)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ListQueryLoggingConfigsRequest {
pub hosted_zone_id: Option<String>,
pub max_results: Option<String>,
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ListQueryLoggingConfigsResponse {
pub next_token: Option<String>,
pub query_logging_configs: Vec<QueryLoggingConfig>,
}
struct ListQueryLoggingConfigsResponseDeserializer;
impl ListQueryLoggingConfigsResponseDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ListQueryLoggingConfigsResponse, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = ListQueryLoggingConfigsResponse::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[..] {
"NextToken" => {
obj.next_token = Some(PaginationTokenDeserializer::deserialize(
"NextToken",
stack,
)?);
}
"QueryLoggingConfigs" => {
obj.query_logging_configs.extend(
QueryLoggingConfigsDeserializer::deserialize(
"QueryLoggingConfigs",
stack,
)?,
);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ListResourceRecordSetsRequest {
pub hosted_zone_id: String,
pub max_items: Option<String>,
pub start_record_identifier: Option<String>,
pub start_record_name: Option<String>,
pub start_record_type: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ListResourceRecordSetsResponse {
pub is_truncated: bool,
pub max_items: String,
pub next_record_identifier: Option<String>,
pub next_record_name: Option<String>,
pub next_record_type: Option<String>,
pub resource_record_sets: Vec<ResourceRecordSet>,
}
struct ListResourceRecordSetsResponseDeserializer;
impl ListResourceRecordSetsResponseDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ListResourceRecordSetsResponse, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = ListResourceRecordSetsResponse::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[..] {
"IsTruncated" => {
obj.is_truncated =
PageTruncatedDeserializer::deserialize("IsTruncated", stack)?;
}
"MaxItems" => {
obj.max_items = PageMaxItemsDeserializer::deserialize("MaxItems", stack)?;
}
"NextRecordIdentifier" => {
obj.next_record_identifier =
Some(ResourceRecordSetIdentifierDeserializer::deserialize(
"NextRecordIdentifier",
stack,
)?);
}
"NextRecordName" => {
obj.next_record_name =
Some(DNSNameDeserializer::deserialize("NextRecordName", stack)?);
}
"NextRecordType" => {
obj.next_record_type =
Some(RRTypeDeserializer::deserialize("NextRecordType", stack)?);
}
"ResourceRecordSets" => {
obj.resource_record_sets.extend(
ResourceRecordSetsDeserializer::deserialize(
"ResourceRecordSets",
stack,
)?,
);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ListReusableDelegationSetsRequest {
pub marker: Option<String>,
pub max_items: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ListReusableDelegationSetsResponse {
pub delegation_sets: Vec<DelegationSet>,
pub is_truncated: bool,
pub marker: String,
pub max_items: String,
pub next_marker: Option<String>,
}
struct ListReusableDelegationSetsResponseDeserializer;
impl ListReusableDelegationSetsResponseDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ListReusableDelegationSetsResponse, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = ListReusableDelegationSetsResponse::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[..] {
"DelegationSets" => {
obj.delegation_sets
.extend(DelegationSetsDeserializer::deserialize(
"DelegationSets",
stack,
)?);
}
"IsTruncated" => {
obj.is_truncated =
PageTruncatedDeserializer::deserialize("IsTruncated", stack)?;
}
"Marker" => {
obj.marker = PageMarkerDeserializer::deserialize("Marker", stack)?;
}
"MaxItems" => {
obj.max_items = PageMaxItemsDeserializer::deserialize("MaxItems", stack)?;
}
"NextMarker" => {
obj.next_marker =
Some(PageMarkerDeserializer::deserialize("NextMarker", stack)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ListTagsForResourceRequest {
pub resource_id: String,
pub resource_type: String,
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ListTagsForResourceResponse {
pub resource_tag_set: ResourceTagSet,
}
struct ListTagsForResourceResponseDeserializer;
impl ListTagsForResourceResponseDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ListTagsForResourceResponse, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = ListTagsForResourceResponse::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[..] {
"ResourceTagSet" => {
obj.resource_tag_set =
ResourceTagSetDeserializer::deserialize("ResourceTagSet", stack)?;
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ListTagsForResourcesRequest {
pub resource_ids: Vec<String>,
pub resource_type: String,
}
pub struct ListTagsForResourcesRequestSerializer;
impl ListTagsForResourcesRequestSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &ListTagsForResourcesRequest,
xmlns: &str,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name).default_ns(xmlns))?;
TagResourceIdListSerializer::serialize(&mut writer, "ResourceIds", &obj.resource_ids)?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ListTagsForResourcesResponse {
pub resource_tag_sets: Vec<ResourceTagSet>,
}
struct ListTagsForResourcesResponseDeserializer;
impl ListTagsForResourcesResponseDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ListTagsForResourcesResponse, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = ListTagsForResourcesResponse::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[..] {
"ResourceTagSets" => {
obj.resource_tag_sets
.extend(ResourceTagSetListDeserializer::deserialize(
"ResourceTagSets",
stack,
)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ListTrafficPoliciesRequest {
pub max_items: Option<String>,
pub traffic_policy_id_marker: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ListTrafficPoliciesResponse {
pub is_truncated: bool,
pub max_items: String,
pub traffic_policy_id_marker: String,
pub traffic_policy_summaries: Vec<TrafficPolicySummary>,
}
struct ListTrafficPoliciesResponseDeserializer;
impl ListTrafficPoliciesResponseDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ListTrafficPoliciesResponse, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = ListTrafficPoliciesResponse::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[..] {
"IsTruncated" => {
obj.is_truncated =
PageTruncatedDeserializer::deserialize("IsTruncated", stack)?;
}
"MaxItems" => {
obj.max_items = PageMaxItemsDeserializer::deserialize("MaxItems", stack)?;
}
"TrafficPolicyIdMarker" => {
obj.traffic_policy_id_marker = TrafficPolicyIdDeserializer::deserialize(
"TrafficPolicyIdMarker",
stack,
)?;
}
"TrafficPolicySummaries" => {
obj.traffic_policy_summaries.extend(
TrafficPolicySummariesDeserializer::deserialize(
"TrafficPolicySummaries",
stack,
)?,
);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ListTrafficPolicyInstancesByHostedZoneRequest {
pub hosted_zone_id: String,
pub max_items: Option<String>,
pub traffic_policy_instance_name_marker: Option<String>,
pub traffic_policy_instance_type_marker: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ListTrafficPolicyInstancesByHostedZoneResponse {
pub is_truncated: bool,
pub max_items: String,
pub traffic_policy_instance_name_marker: Option<String>,
pub traffic_policy_instance_type_marker: Option<String>,
pub traffic_policy_instances: Vec<TrafficPolicyInstance>,
}
struct ListTrafficPolicyInstancesByHostedZoneResponseDeserializer;
impl ListTrafficPolicyInstancesByHostedZoneResponseDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ListTrafficPolicyInstancesByHostedZoneResponse, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = ListTrafficPolicyInstancesByHostedZoneResponse::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[..] {
"IsTruncated" => {
obj.is_truncated =
PageTruncatedDeserializer::deserialize("IsTruncated", stack)?;
}
"MaxItems" => {
obj.max_items = PageMaxItemsDeserializer::deserialize("MaxItems", stack)?;
}
"TrafficPolicyInstanceNameMarker" => {
obj.traffic_policy_instance_name_marker =
Some(DNSNameDeserializer::deserialize(
"TrafficPolicyInstanceNameMarker",
stack,
)?);
}
"TrafficPolicyInstanceTypeMarker" => {
obj.traffic_policy_instance_type_marker =
Some(RRTypeDeserializer::deserialize(
"TrafficPolicyInstanceTypeMarker",
stack,
)?);
}
"TrafficPolicyInstances" => {
obj.traffic_policy_instances.extend(
TrafficPolicyInstancesDeserializer::deserialize(
"TrafficPolicyInstances",
stack,
)?,
);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ListTrafficPolicyInstancesByPolicyRequest {
pub hosted_zone_id_marker: Option<String>,
pub max_items: Option<String>,
pub traffic_policy_id: String,
pub traffic_policy_instance_name_marker: Option<String>,
pub traffic_policy_instance_type_marker: Option<String>,
pub traffic_policy_version: i64,
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ListTrafficPolicyInstancesByPolicyResponse {
pub hosted_zone_id_marker: Option<String>,
pub is_truncated: bool,
pub max_items: String,
pub traffic_policy_instance_name_marker: Option<String>,
pub traffic_policy_instance_type_marker: Option<String>,
pub traffic_policy_instances: Vec<TrafficPolicyInstance>,
}
struct ListTrafficPolicyInstancesByPolicyResponseDeserializer;
impl ListTrafficPolicyInstancesByPolicyResponseDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ListTrafficPolicyInstancesByPolicyResponse, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = ListTrafficPolicyInstancesByPolicyResponse::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[..] {
"HostedZoneIdMarker" => {
obj.hosted_zone_id_marker = Some(ResourceIdDeserializer::deserialize(
"HostedZoneIdMarker",
stack,
)?);
}
"IsTruncated" => {
obj.is_truncated =
PageTruncatedDeserializer::deserialize("IsTruncated", stack)?;
}
"MaxItems" => {
obj.max_items = PageMaxItemsDeserializer::deserialize("MaxItems", stack)?;
}
"TrafficPolicyInstanceNameMarker" => {
obj.traffic_policy_instance_name_marker =
Some(DNSNameDeserializer::deserialize(
"TrafficPolicyInstanceNameMarker",
stack,
)?);
}
"TrafficPolicyInstanceTypeMarker" => {
obj.traffic_policy_instance_type_marker =
Some(RRTypeDeserializer::deserialize(
"TrafficPolicyInstanceTypeMarker",
stack,
)?);
}
"TrafficPolicyInstances" => {
obj.traffic_policy_instances.extend(
TrafficPolicyInstancesDeserializer::deserialize(
"TrafficPolicyInstances",
stack,
)?,
);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ListTrafficPolicyInstancesRequest {
pub hosted_zone_id_marker: Option<String>,
pub max_items: Option<String>,
pub traffic_policy_instance_name_marker: Option<String>,
pub traffic_policy_instance_type_marker: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ListTrafficPolicyInstancesResponse {
pub hosted_zone_id_marker: Option<String>,
pub is_truncated: bool,
pub max_items: String,
pub traffic_policy_instance_name_marker: Option<String>,
pub traffic_policy_instance_type_marker: Option<String>,
pub traffic_policy_instances: Vec<TrafficPolicyInstance>,
}
struct ListTrafficPolicyInstancesResponseDeserializer;
impl ListTrafficPolicyInstancesResponseDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ListTrafficPolicyInstancesResponse, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = ListTrafficPolicyInstancesResponse::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[..] {
"HostedZoneIdMarker" => {
obj.hosted_zone_id_marker = Some(ResourceIdDeserializer::deserialize(
"HostedZoneIdMarker",
stack,
)?);
}
"IsTruncated" => {
obj.is_truncated =
PageTruncatedDeserializer::deserialize("IsTruncated", stack)?;
}
"MaxItems" => {
obj.max_items = PageMaxItemsDeserializer::deserialize("MaxItems", stack)?;
}
"TrafficPolicyInstanceNameMarker" => {
obj.traffic_policy_instance_name_marker =
Some(DNSNameDeserializer::deserialize(
"TrafficPolicyInstanceNameMarker",
stack,
)?);
}
"TrafficPolicyInstanceTypeMarker" => {
obj.traffic_policy_instance_type_marker =
Some(RRTypeDeserializer::deserialize(
"TrafficPolicyInstanceTypeMarker",
stack,
)?);
}
"TrafficPolicyInstances" => {
obj.traffic_policy_instances.extend(
TrafficPolicyInstancesDeserializer::deserialize(
"TrafficPolicyInstances",
stack,
)?,
);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ListTrafficPolicyVersionsRequest {
pub id: String,
pub max_items: Option<String>,
pub traffic_policy_version_marker: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ListTrafficPolicyVersionsResponse {
pub is_truncated: bool,
pub max_items: String,
pub traffic_policies: Vec<TrafficPolicy>,
pub traffic_policy_version_marker: String,
}
struct ListTrafficPolicyVersionsResponseDeserializer;
impl ListTrafficPolicyVersionsResponseDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ListTrafficPolicyVersionsResponse, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = ListTrafficPolicyVersionsResponse::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[..] {
"IsTruncated" => {
obj.is_truncated =
PageTruncatedDeserializer::deserialize("IsTruncated", stack)?;
}
"MaxItems" => {
obj.max_items = PageMaxItemsDeserializer::deserialize("MaxItems", stack)?;
}
"TrafficPolicies" => {
obj.traffic_policies
.extend(TrafficPoliciesDeserializer::deserialize(
"TrafficPolicies",
stack,
)?);
}
"TrafficPolicyVersionMarker" => {
obj.traffic_policy_version_marker =
TrafficPolicyVersionMarkerDeserializer::deserialize(
"TrafficPolicyVersionMarker",
stack,
)?;
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ListVPCAssociationAuthorizationsRequest {
pub hosted_zone_id: String,
pub max_results: Option<String>,
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ListVPCAssociationAuthorizationsResponse {
pub hosted_zone_id: String,
pub next_token: Option<String>,
pub vp_cs: Vec<VPC>,
}
struct ListVPCAssociationAuthorizationsResponseDeserializer;
impl ListVPCAssociationAuthorizationsResponseDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ListVPCAssociationAuthorizationsResponse, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = ListVPCAssociationAuthorizationsResponse::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[..] {
"HostedZoneId" => {
obj.hosted_zone_id =
ResourceIdDeserializer::deserialize("HostedZoneId", stack)?;
}
"NextToken" => {
obj.next_token = Some(PaginationTokenDeserializer::deserialize(
"NextToken",
stack,
)?);
}
"VPCs" => {
obj.vp_cs
.extend(VPCsDeserializer::deserialize("VPCs", stack)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
pub struct MaxResultsSerializer;
impl MaxResultsSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &String,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.to_string()
)))?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
struct MeasureLatencyDeserializer;
impl MeasureLatencyDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<bool, XmlParseError> {
start_element(tag_name, stack)?;
let obj = bool::from_str(characters(stack)?.as_ref()).unwrap();
end_element(tag_name, stack)?;
Ok(obj)
}
}
pub struct MeasureLatencySerializer;
impl MeasureLatencySerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &bool,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.to_string()
)))?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
struct MessageDeserializer;
impl MessageDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct MetricNameDeserializer;
impl MetricNameDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct NameserverDeserializer;
impl NameserverDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct NamespaceDeserializer;
impl NamespaceDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct NonceDeserializer;
impl NonceDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
pub struct NonceSerializer;
impl NonceSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &String,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.to_string()
)))?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
struct PageMarkerDeserializer;
impl PageMarkerDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
pub struct PageMarkerSerializer;
impl PageMarkerSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &String,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.to_string()
)))?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
struct PageMaxItemsDeserializer;
impl PageMaxItemsDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
pub struct PageMaxItemsSerializer;
impl PageMaxItemsSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &String,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.to_string()
)))?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
struct PageTruncatedDeserializer;
impl PageTruncatedDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<bool, XmlParseError> {
start_element(tag_name, stack)?;
let obj = bool::from_str(characters(stack)?.as_ref()).unwrap();
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct PaginationTokenDeserializer;
impl PaginationTokenDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
pub struct PaginationTokenSerializer;
impl PaginationTokenSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &String,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.to_string()
)))?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
struct PeriodDeserializer;
impl PeriodDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<i64, XmlParseError> {
start_element(tag_name, stack)?;
let obj = i64::from_str(characters(stack)?.as_ref()).unwrap();
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct PortDeserializer;
impl PortDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<i64, XmlParseError> {
start_element(tag_name, stack)?;
let obj = i64::from_str(characters(stack)?.as_ref()).unwrap();
end_element(tag_name, stack)?;
Ok(obj)
}
}
pub struct PortSerializer;
impl PortSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &i64,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.to_string()
)))?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct QueryLoggingConfig {
pub cloud_watch_logs_log_group_arn: String,
pub hosted_zone_id: String,
pub id: String,
}
struct QueryLoggingConfigDeserializer;
impl QueryLoggingConfigDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<QueryLoggingConfig, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = QueryLoggingConfig::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[..] {
"CloudWatchLogsLogGroupArn" => {
obj.cloud_watch_logs_log_group_arn =
CloudWatchLogsLogGroupArnDeserializer::deserialize(
"CloudWatchLogsLogGroupArn",
stack,
)?;
}
"HostedZoneId" => {
obj.hosted_zone_id =
ResourceIdDeserializer::deserialize("HostedZoneId", stack)?;
}
"Id" => {
obj.id = QueryLoggingConfigIdDeserializer::deserialize("Id", stack)?;
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct QueryLoggingConfigIdDeserializer;
impl QueryLoggingConfigIdDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
pub struct QueryLoggingConfigIdSerializer;
impl QueryLoggingConfigIdSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &String,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.to_string()
)))?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
struct QueryLoggingConfigsDeserializer;
impl QueryLoggingConfigsDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<QueryLoggingConfig>, XmlParseError> {
let mut obj = vec![];
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 == "QueryLoggingConfig" {
obj.push(QueryLoggingConfigDeserializer::deserialize(
"QueryLoggingConfig",
stack,
)?);
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
end_element(tag_name, stack)?;
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
struct RDataDeserializer;
impl RDataDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
pub struct RDataSerializer;
impl RDataSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &String,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.to_string()
)))?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
struct RRTypeDeserializer;
impl RRTypeDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
pub struct RRTypeSerializer;
impl RRTypeSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &String,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.to_string()
)))?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
struct RecordDataDeserializer;
impl RecordDataDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<String>, XmlParseError> {
let mut obj = vec![];
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 == "RecordDataEntry" {
obj.push(RecordDataEntryDeserializer::deserialize(
"RecordDataEntry",
stack,
)?);
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
end_element(tag_name, stack)?;
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
struct RecordDataEntryDeserializer;
impl RecordDataEntryDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct RequestIntervalDeserializer;
impl RequestIntervalDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<i64, XmlParseError> {
start_element(tag_name, stack)?;
let obj = i64::from_str(characters(stack)?.as_ref()).unwrap();
end_element(tag_name, stack)?;
Ok(obj)
}
}
pub struct RequestIntervalSerializer;
impl RequestIntervalSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &i64,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.to_string()
)))?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
pub struct ResettableElementNameSerializer;
impl ResettableElementNameSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &String,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.to_string()
)))?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
pub struct ResettableElementNameListSerializer;
impl ResettableElementNameListSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &Vec<String>,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
for element in obj {
ResettableElementNameSerializer::serialize(writer, "ResettableElementName", element)?;
}
writer.write(xml::writer::XmlEvent::end_element())?;
Ok(())
}
}
struct ResourceDescriptionDeserializer;
impl ResourceDescriptionDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
pub struct ResourceDescriptionSerializer;
impl ResourceDescriptionSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &String,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.to_string()
)))?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
struct ResourceIdDeserializer;
impl ResourceIdDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
pub struct ResourceIdSerializer;
impl ResourceIdSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &String,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.to_string()
)))?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
struct ResourcePathDeserializer;
impl ResourcePathDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
pub struct ResourcePathSerializer;
impl ResourcePathSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &String,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.to_string()
)))?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ResourceRecord {
pub value: String,
}
struct ResourceRecordDeserializer;
impl ResourceRecordDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ResourceRecord, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = ResourceRecord::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[..] {
"Value" => {
obj.value = RDataDeserializer::deserialize("Value", stack)?;
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
pub struct ResourceRecordSerializer;
impl ResourceRecordSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &ResourceRecord,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
writer.write(xml::writer::XmlEvent::start_element("Value"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.value
)))?;
writer.write(xml::writer::XmlEvent::end_element())?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ResourceRecordSet {
pub alias_target: Option<AliasTarget>,
pub failover: Option<String>,
pub geo_location: Option<GeoLocation>,
pub health_check_id: Option<String>,
pub multi_value_answer: Option<bool>,
pub name: String,
pub region: Option<String>,
pub resource_records: Option<Vec<ResourceRecord>>,
pub set_identifier: Option<String>,
pub ttl: Option<i64>,
pub traffic_policy_instance_id: Option<String>,
pub type_: String,
pub weight: Option<i64>,
}
struct ResourceRecordSetDeserializer;
impl ResourceRecordSetDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ResourceRecordSet, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = ResourceRecordSet::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[..] {
"AliasTarget" => {
obj.alias_target =
Some(AliasTargetDeserializer::deserialize("AliasTarget", stack)?);
}
"Failover" => {
obj.failover = Some(ResourceRecordSetFailoverDeserializer::deserialize(
"Failover", stack,
)?);
}
"GeoLocation" => {
obj.geo_location =
Some(GeoLocationDeserializer::deserialize("GeoLocation", stack)?);
}
"HealthCheckId" => {
obj.health_check_id = Some(HealthCheckIdDeserializer::deserialize(
"HealthCheckId",
stack,
)?);
}
"MultiValueAnswer" => {
obj.multi_value_answer =
Some(ResourceRecordSetMultiValueAnswerDeserializer::deserialize(
"MultiValueAnswer",
stack,
)?);
}
"Name" => {
obj.name = DNSNameDeserializer::deserialize("Name", stack)?;
}
"Region" => {
obj.region = Some(ResourceRecordSetRegionDeserializer::deserialize(
"Region", stack,
)?);
}
"ResourceRecords" => {
obj.resource_records = match obj.resource_records {
Some(ref mut existing) => {
existing.extend(ResourceRecordsDeserializer::deserialize(
"ResourceRecords",
stack,
)?);
Some(existing.to_vec())
}
None => Some(ResourceRecordsDeserializer::deserialize(
"ResourceRecords",
stack,
)?),
};
}
"SetIdentifier" => {
obj.set_identifier =
Some(ResourceRecordSetIdentifierDeserializer::deserialize(
"SetIdentifier",
stack,
)?);
}
"TTL" => {
obj.ttl = Some(TTLDeserializer::deserialize("TTL", stack)?);
}
"TrafficPolicyInstanceId" => {
obj.traffic_policy_instance_id =
Some(TrafficPolicyInstanceIdDeserializer::deserialize(
"TrafficPolicyInstanceId",
stack,
)?);
}
"Type" => {
obj.type_ = RRTypeDeserializer::deserialize("Type", stack)?;
}
"Weight" => {
obj.weight = Some(ResourceRecordSetWeightDeserializer::deserialize(
"Weight", stack,
)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
pub struct ResourceRecordSetSerializer;
impl ResourceRecordSetSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &ResourceRecordSet,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
if let Some(ref value) = obj.alias_target {
&AliasTargetSerializer::serialize(&mut writer, "AliasTarget", value)?;
}
if let Some(ref value) = obj.failover {
writer.write(xml::writer::XmlEvent::start_element("Failover"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = value
)));
writer.write(xml::writer::XmlEvent::end_element())?;
}
if let Some(ref value) = obj.geo_location {
&GeoLocationSerializer::serialize(&mut writer, "GeoLocation", value)?;
}
if let Some(ref value) = obj.health_check_id {
writer.write(xml::writer::XmlEvent::start_element("HealthCheckId"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = value
)));
writer.write(xml::writer::XmlEvent::end_element())?;
}
if let Some(ref value) = obj.multi_value_answer {
writer.write(xml::writer::XmlEvent::start_element("MultiValueAnswer"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = value
)));
writer.write(xml::writer::XmlEvent::end_element())?;
}
writer.write(xml::writer::XmlEvent::start_element("Name"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.name
)))?;
writer.write(xml::writer::XmlEvent::end_element())?;
if let Some(ref value) = obj.region {
writer.write(xml::writer::XmlEvent::start_element("Region"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = value
)));
writer.write(xml::writer::XmlEvent::end_element())?;
}
if let Some(ref value) = obj.resource_records {
&ResourceRecordsSerializer::serialize(&mut writer, "ResourceRecords", value)?;
}
if let Some(ref value) = obj.set_identifier {
writer.write(xml::writer::XmlEvent::start_element("SetIdentifier"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = value
)));
writer.write(xml::writer::XmlEvent::end_element())?;
}
if let Some(ref value) = obj.ttl {
writer.write(xml::writer::XmlEvent::start_element("TTL"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = value
)));
writer.write(xml::writer::XmlEvent::end_element())?;
}
if let Some(ref value) = obj.traffic_policy_instance_id {
writer.write(xml::writer::XmlEvent::start_element(
"TrafficPolicyInstanceId",
))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = value
)));
writer.write(xml::writer::XmlEvent::end_element())?;
}
writer.write(xml::writer::XmlEvent::start_element("Type"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.type_
)))?;
writer.write(xml::writer::XmlEvent::end_element())?;
if let Some(ref value) = obj.weight {
writer.write(xml::writer::XmlEvent::start_element("Weight"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = value
)));
writer.write(xml::writer::XmlEvent::end_element())?;
}
writer.write(xml::writer::XmlEvent::end_element())
}
}
struct ResourceRecordSetFailoverDeserializer;
impl ResourceRecordSetFailoverDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
pub struct ResourceRecordSetFailoverSerializer;
impl ResourceRecordSetFailoverSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &String,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.to_string()
)))?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
struct ResourceRecordSetIdentifierDeserializer;
impl ResourceRecordSetIdentifierDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
pub struct ResourceRecordSetIdentifierSerializer;
impl ResourceRecordSetIdentifierSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &String,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.to_string()
)))?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
struct ResourceRecordSetMultiValueAnswerDeserializer;
impl ResourceRecordSetMultiValueAnswerDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<bool, XmlParseError> {
start_element(tag_name, stack)?;
let obj = bool::from_str(characters(stack)?.as_ref()).unwrap();
end_element(tag_name, stack)?;
Ok(obj)
}
}
pub struct ResourceRecordSetMultiValueAnswerSerializer;
impl ResourceRecordSetMultiValueAnswerSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &bool,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.to_string()
)))?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
struct ResourceRecordSetRegionDeserializer;
impl ResourceRecordSetRegionDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
pub struct ResourceRecordSetRegionSerializer;
impl ResourceRecordSetRegionSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &String,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.to_string()
)))?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
struct ResourceRecordSetWeightDeserializer;
impl ResourceRecordSetWeightDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<i64, XmlParseError> {
start_element(tag_name, stack)?;
let obj = i64::from_str(characters(stack)?.as_ref()).unwrap();
end_element(tag_name, stack)?;
Ok(obj)
}
}
pub struct ResourceRecordSetWeightSerializer;
impl ResourceRecordSetWeightSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &i64,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.to_string()
)))?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
struct ResourceRecordSetsDeserializer;
impl ResourceRecordSetsDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<ResourceRecordSet>, XmlParseError> {
let mut obj = vec![];
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 == "ResourceRecordSet" {
obj.push(ResourceRecordSetDeserializer::deserialize(
"ResourceRecordSet",
stack,
)?);
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
end_element(tag_name, stack)?;
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
struct ResourceRecordsDeserializer;
impl ResourceRecordsDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<ResourceRecord>, XmlParseError> {
let mut obj = vec![];
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 == "ResourceRecord" {
obj.push(ResourceRecordDeserializer::deserialize(
"ResourceRecord",
stack,
)?);
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
end_element(tag_name, stack)?;
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
pub struct ResourceRecordsSerializer;
impl ResourceRecordsSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &Vec<ResourceRecord>,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
for element in obj {
ResourceRecordSerializer::serialize(writer, "ResourceRecord", element)?;
}
writer.write(xml::writer::XmlEvent::end_element())?;
Ok(())
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ResourceTagSet {
pub resource_id: Option<String>,
pub resource_type: Option<String>,
pub tags: Option<Vec<Tag>>,
}
struct ResourceTagSetDeserializer;
impl ResourceTagSetDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ResourceTagSet, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = ResourceTagSet::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[..] {
"ResourceId" => {
obj.resource_id =
Some(TagResourceIdDeserializer::deserialize("ResourceId", stack)?);
}
"ResourceType" => {
obj.resource_type = Some(TagResourceTypeDeserializer::deserialize(
"ResourceType",
stack,
)?);
}
"Tags" => {
obj.tags = match obj.tags {
Some(ref mut existing) => {
existing.extend(TagListDeserializer::deserialize("Tags", stack)?);
Some(existing.to_vec())
}
None => Some(TagListDeserializer::deserialize("Tags", stack)?),
};
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct ResourceTagSetListDeserializer;
impl ResourceTagSetListDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<ResourceTagSet>, XmlParseError> {
let mut obj = vec![];
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 == "ResourceTagSet" {
obj.push(ResourceTagSetDeserializer::deserialize(
"ResourceTagSet",
stack,
)?);
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
end_element(tag_name, stack)?;
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ReusableDelegationSetLimit {
pub type_: String,
pub value: i64,
}
struct ReusableDelegationSetLimitDeserializer;
impl ReusableDelegationSetLimitDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ReusableDelegationSetLimit, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = ReusableDelegationSetLimit::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[..] {
"Type" => {
obj.type_ =
ReusableDelegationSetLimitTypeDeserializer::deserialize("Type", stack)?;
}
"Value" => {
obj.value = LimitValueDeserializer::deserialize("Value", stack)?;
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct ReusableDelegationSetLimitTypeDeserializer;
impl ReusableDelegationSetLimitTypeDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
pub struct ReusableDelegationSetLimitTypeSerializer;
impl ReusableDelegationSetLimitTypeSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &String,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.to_string()
)))?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
struct SearchStringDeserializer;
impl SearchStringDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
pub struct SearchStringSerializer;
impl SearchStringSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &String,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.to_string()
)))?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
struct ServicePrincipalDeserializer;
impl ServicePrincipalDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct StatisticDeserializer;
impl StatisticDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct StatusDeserializer;
impl StatusDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct StatusReport {
pub checked_time: Option<String>,
pub status: Option<String>,
}
struct StatusReportDeserializer;
impl StatusReportDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<StatusReport, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = StatusReport::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[..] {
"CheckedTime" => {
obj.checked_time =
Some(TimeStampDeserializer::deserialize("CheckedTime", stack)?);
}
"Status" => {
obj.status = Some(StatusDeserializer::deserialize("Status", stack)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
pub struct SubnetMaskSerializer;
impl SubnetMaskSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &String,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.to_string()
)))?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
struct TTLDeserializer;
impl TTLDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<i64, XmlParseError> {
start_element(tag_name, stack)?;
let obj = i64::from_str(characters(stack)?.as_ref()).unwrap();
end_element(tag_name, stack)?;
Ok(obj)
}
}
pub struct TTLSerializer;
impl TTLSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &i64,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.to_string()
)))?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct Tag {
pub key: Option<String>,
pub value: Option<String>,
}
struct TagDeserializer;
impl TagDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Tag, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = Tag::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[..] {
"Key" => {
obj.key = Some(TagKeyDeserializer::deserialize("Key", stack)?);
}
"Value" => {
obj.value = Some(TagValueDeserializer::deserialize("Value", stack)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
pub struct TagSerializer;
impl TagSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &Tag,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
if let Some(ref value) = obj.key {
writer.write(xml::writer::XmlEvent::start_element("Key"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = value
)));
writer.write(xml::writer::XmlEvent::end_element())?;
}
if let Some(ref value) = obj.value {
writer.write(xml::writer::XmlEvent::start_element("Value"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = value
)));
writer.write(xml::writer::XmlEvent::end_element())?;
}
writer.write(xml::writer::XmlEvent::end_element())
}
}
struct TagKeyDeserializer;
impl TagKeyDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
pub struct TagKeySerializer;
impl TagKeySerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &String,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.to_string()
)))?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
pub struct TagKeyListSerializer;
impl TagKeyListSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &Vec<String>,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
for element in obj {
TagKeySerializer::serialize(writer, "Key", element)?;
}
writer.write(xml::writer::XmlEvent::end_element())?;
Ok(())
}
}
struct TagListDeserializer;
impl TagListDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<Tag>, XmlParseError> {
let mut obj = vec![];
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 == "Tag" {
obj.push(TagDeserializer::deserialize("Tag", stack)?);
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
end_element(tag_name, stack)?;
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
pub struct TagListSerializer;
impl TagListSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &Vec<Tag>,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
for element in obj {
TagSerializer::serialize(writer, "Tag", element)?;
}
writer.write(xml::writer::XmlEvent::end_element())?;
Ok(())
}
}
struct TagResourceIdDeserializer;
impl TagResourceIdDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
pub struct TagResourceIdSerializer;
impl TagResourceIdSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &String,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.to_string()
)))?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
pub struct TagResourceIdListSerializer;
impl TagResourceIdListSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &Vec<String>,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
for element in obj {
TagResourceIdSerializer::serialize(writer, "ResourceId", element)?;
}
writer.write(xml::writer::XmlEvent::end_element())?;
Ok(())
}
}
struct TagResourceTypeDeserializer;
impl TagResourceTypeDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
pub struct TagResourceTypeSerializer;
impl TagResourceTypeSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &String,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.to_string()
)))?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
struct TagValueDeserializer;
impl TagValueDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
pub struct TagValueSerializer;
impl TagValueSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &String,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.to_string()
)))?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct TestDNSAnswerRequest {
pub edns0_client_subnet_ip: Option<String>,
pub edns0_client_subnet_mask: Option<String>,
pub hosted_zone_id: String,
pub record_name: String,
pub record_type: String,
pub resolver_ip: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct TestDNSAnswerResponse {
pub nameserver: String,
pub protocol: String,
pub record_data: Vec<String>,
pub record_name: String,
pub record_type: String,
pub response_code: String,
}
struct TestDNSAnswerResponseDeserializer;
impl TestDNSAnswerResponseDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<TestDNSAnswerResponse, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = TestDNSAnswerResponse::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[..] {
"Nameserver" => {
obj.nameserver = NameserverDeserializer::deserialize("Nameserver", stack)?;
}
"Protocol" => {
obj.protocol =
TransportProtocolDeserializer::deserialize("Protocol", stack)?;
}
"RecordData" => {
obj.record_data
.extend(RecordDataDeserializer::deserialize("RecordData", stack)?);
}
"RecordName" => {
obj.record_name = DNSNameDeserializer::deserialize("RecordName", stack)?;
}
"RecordType" => {
obj.record_type = RRTypeDeserializer::deserialize("RecordType", stack)?;
}
"ResponseCode" => {
obj.response_code =
DNSRCodeDeserializer::deserialize("ResponseCode", stack)?;
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct ThresholdDeserializer;
impl ThresholdDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<f64, XmlParseError> {
start_element(tag_name, stack)?;
let obj = f64::from_str(characters(stack)?.as_ref()).unwrap();
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct TimeStampDeserializer;
impl TimeStampDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct TrafficPoliciesDeserializer;
impl TrafficPoliciesDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<TrafficPolicy>, XmlParseError> {
let mut obj = vec![];
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 == "TrafficPolicy" {
obj.push(TrafficPolicyDeserializer::deserialize(
"TrafficPolicy",
stack,
)?);
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
end_element(tag_name, stack)?;
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct TrafficPolicy {
pub comment: Option<String>,
pub document: String,
pub id: String,
pub name: String,
pub type_: String,
pub version: i64,
}
struct TrafficPolicyDeserializer;
impl TrafficPolicyDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<TrafficPolicy, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = TrafficPolicy::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[..] {
"Comment" => {
obj.comment = Some(TrafficPolicyCommentDeserializer::deserialize(
"Comment", stack,
)?);
}
"Document" => {
obj.document =
TrafficPolicyDocumentDeserializer::deserialize("Document", stack)?;
}
"Id" => {
obj.id = TrafficPolicyIdDeserializer::deserialize("Id", stack)?;
}
"Name" => {
obj.name = TrafficPolicyNameDeserializer::deserialize("Name", stack)?;
}
"Type" => {
obj.type_ = RRTypeDeserializer::deserialize("Type", stack)?;
}
"Version" => {
obj.version =
TrafficPolicyVersionDeserializer::deserialize("Version", stack)?;
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct TrafficPolicyCommentDeserializer;
impl TrafficPolicyCommentDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
pub struct TrafficPolicyCommentSerializer;
impl TrafficPolicyCommentSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &String,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.to_string()
)))?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
struct TrafficPolicyDocumentDeserializer;
impl TrafficPolicyDocumentDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
pub struct TrafficPolicyDocumentSerializer;
impl TrafficPolicyDocumentSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &String,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.to_string()
)))?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
struct TrafficPolicyIdDeserializer;
impl TrafficPolicyIdDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
pub struct TrafficPolicyIdSerializer;
impl TrafficPolicyIdSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &String,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.to_string()
)))?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct TrafficPolicyInstance {
pub hosted_zone_id: String,
pub id: String,
pub message: String,
pub name: String,
pub state: String,
pub ttl: i64,
pub traffic_policy_id: String,
pub traffic_policy_type: String,
pub traffic_policy_version: i64,
}
struct TrafficPolicyInstanceDeserializer;
impl TrafficPolicyInstanceDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<TrafficPolicyInstance, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = TrafficPolicyInstance::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[..] {
"HostedZoneId" => {
obj.hosted_zone_id =
ResourceIdDeserializer::deserialize("HostedZoneId", stack)?;
}
"Id" => {
obj.id = TrafficPolicyInstanceIdDeserializer::deserialize("Id", stack)?;
}
"Message" => {
obj.message = MessageDeserializer::deserialize("Message", stack)?;
}
"Name" => {
obj.name = DNSNameDeserializer::deserialize("Name", stack)?;
}
"State" => {
obj.state =
TrafficPolicyInstanceStateDeserializer::deserialize("State", stack)?;
}
"TTL" => {
obj.ttl = TTLDeserializer::deserialize("TTL", stack)?;
}
"TrafficPolicyId" => {
obj.traffic_policy_id =
TrafficPolicyIdDeserializer::deserialize("TrafficPolicyId", stack)?;
}
"TrafficPolicyType" => {
obj.traffic_policy_type =
RRTypeDeserializer::deserialize("TrafficPolicyType", stack)?;
}
"TrafficPolicyVersion" => {
obj.traffic_policy_version = TrafficPolicyVersionDeserializer::deserialize(
"TrafficPolicyVersion",
stack,
)?;
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct TrafficPolicyInstanceCountDeserializer;
impl TrafficPolicyInstanceCountDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<i64, XmlParseError> {
start_element(tag_name, stack)?;
let obj = i64::from_str(characters(stack)?.as_ref()).unwrap();
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct TrafficPolicyInstanceIdDeserializer;
impl TrafficPolicyInstanceIdDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
pub struct TrafficPolicyInstanceIdSerializer;
impl TrafficPolicyInstanceIdSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &String,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.to_string()
)))?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
struct TrafficPolicyInstanceStateDeserializer;
impl TrafficPolicyInstanceStateDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct TrafficPolicyInstancesDeserializer;
impl TrafficPolicyInstancesDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<TrafficPolicyInstance>, XmlParseError> {
let mut obj = vec![];
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 == "TrafficPolicyInstance" {
obj.push(TrafficPolicyInstanceDeserializer::deserialize(
"TrafficPolicyInstance",
stack,
)?);
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
end_element(tag_name, stack)?;
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
struct TrafficPolicyNameDeserializer;
impl TrafficPolicyNameDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
pub struct TrafficPolicyNameSerializer;
impl TrafficPolicyNameSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &String,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.to_string()
)))?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
struct TrafficPolicySummariesDeserializer;
impl TrafficPolicySummariesDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<TrafficPolicySummary>, XmlParseError> {
let mut obj = vec![];
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 == "TrafficPolicySummary" {
obj.push(TrafficPolicySummaryDeserializer::deserialize(
"TrafficPolicySummary",
stack,
)?);
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
end_element(tag_name, stack)?;
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct TrafficPolicySummary {
pub id: String,
pub latest_version: i64,
pub name: String,
pub traffic_policy_count: i64,
pub type_: String,
}
struct TrafficPolicySummaryDeserializer;
impl TrafficPolicySummaryDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<TrafficPolicySummary, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = TrafficPolicySummary::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[..] {
"Id" => {
obj.id = TrafficPolicyIdDeserializer::deserialize("Id", stack)?;
}
"LatestVersion" => {
obj.latest_version =
TrafficPolicyVersionDeserializer::deserialize("LatestVersion", stack)?;
}
"Name" => {
obj.name = TrafficPolicyNameDeserializer::deserialize("Name", stack)?;
}
"TrafficPolicyCount" => {
obj.traffic_policy_count = TrafficPolicyVersionDeserializer::deserialize(
"TrafficPolicyCount",
stack,
)?;
}
"Type" => {
obj.type_ = RRTypeDeserializer::deserialize("Type", stack)?;
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct TrafficPolicyVersionDeserializer;
impl TrafficPolicyVersionDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<i64, XmlParseError> {
start_element(tag_name, stack)?;
let obj = i64::from_str(characters(stack)?.as_ref()).unwrap();
end_element(tag_name, stack)?;
Ok(obj)
}
}
pub struct TrafficPolicyVersionSerializer;
impl TrafficPolicyVersionSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &i64,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.to_string()
)))?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
struct TrafficPolicyVersionMarkerDeserializer;
impl TrafficPolicyVersionMarkerDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
pub struct TrafficPolicyVersionMarkerSerializer;
impl TrafficPolicyVersionMarkerSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &String,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.to_string()
)))?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
struct TransportProtocolDeserializer;
impl TransportProtocolDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct UpdateHealthCheckRequest {
pub alarm_identifier: Option<AlarmIdentifier>,
pub child_health_checks: Option<Vec<String>>,
pub disabled: Option<bool>,
pub enable_sni: Option<bool>,
pub failure_threshold: Option<i64>,
pub fully_qualified_domain_name: Option<String>,
pub health_check_id: String,
pub health_check_version: Option<i64>,
pub health_threshold: Option<i64>,
pub ip_address: Option<String>,
pub insufficient_data_health_status: Option<String>,
pub inverted: Option<bool>,
pub port: Option<i64>,
pub regions: Option<Vec<String>>,
pub reset_elements: Option<Vec<String>>,
pub resource_path: Option<String>,
pub search_string: Option<String>,
}
pub struct UpdateHealthCheckRequestSerializer;
impl UpdateHealthCheckRequestSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &UpdateHealthCheckRequest,
xmlns: &str,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name).default_ns(xmlns))?;
if let Some(ref value) = obj.alarm_identifier {
&AlarmIdentifierSerializer::serialize(&mut writer, "AlarmIdentifier", value)?;
}
if let Some(ref value) = obj.child_health_checks {
&ChildHealthCheckListSerializer::serialize(&mut writer, "ChildHealthChecks", value)?;
}
if let Some(ref value) = obj.disabled {
&DisabledSerializer::serialize(&mut writer, "Disabled", value)?;
}
if let Some(ref value) = obj.enable_sni {
&EnableSNISerializer::serialize(&mut writer, "EnableSNI", value)?;
}
if let Some(ref value) = obj.failure_threshold {
&FailureThresholdSerializer::serialize(&mut writer, "FailureThreshold", value)?;
}
if let Some(ref value) = obj.fully_qualified_domain_name {
&FullyQualifiedDomainNameSerializer::serialize(
&mut writer,
"FullyQualifiedDomainName",
value,
)?;
}
if let Some(ref value) = obj.health_check_version {
&HealthCheckVersionSerializer::serialize(&mut writer, "HealthCheckVersion", value)?;
}
if let Some(ref value) = obj.health_threshold {
&HealthThresholdSerializer::serialize(&mut writer, "HealthThreshold", value)?;
}
if let Some(ref value) = obj.ip_address {
&IPAddressSerializer::serialize(&mut writer, "IPAddress", value)?;
}
if let Some(ref value) = obj.insufficient_data_health_status {
&InsufficientDataHealthStatusSerializer::serialize(
&mut writer,
"InsufficientDataHealthStatus",
value,
)?;
}
if let Some(ref value) = obj.inverted {
&InvertedSerializer::serialize(&mut writer, "Inverted", value)?;
}
if let Some(ref value) = obj.port {
&PortSerializer::serialize(&mut writer, "Port", value)?;
}
if let Some(ref value) = obj.regions {
&HealthCheckRegionListSerializer::serialize(&mut writer, "Regions", value)?;
}
if let Some(ref value) = obj.reset_elements {
&ResettableElementNameListSerializer::serialize(&mut writer, "ResetElements", value)?;
}
if let Some(ref value) = obj.resource_path {
&ResourcePathSerializer::serialize(&mut writer, "ResourcePath", value)?;
}
if let Some(ref value) = obj.search_string {
&SearchStringSerializer::serialize(&mut writer, "SearchString", value)?;
}
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct UpdateHealthCheckResponse {
pub health_check: HealthCheck,
}
struct UpdateHealthCheckResponseDeserializer;
impl UpdateHealthCheckResponseDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<UpdateHealthCheckResponse, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = UpdateHealthCheckResponse::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[..] {
"HealthCheck" => {
obj.health_check =
HealthCheckDeserializer::deserialize("HealthCheck", stack)?;
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct UpdateHostedZoneCommentRequest {
pub comment: Option<String>,
pub id: String,
}
pub struct UpdateHostedZoneCommentRequestSerializer;
impl UpdateHostedZoneCommentRequestSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &UpdateHostedZoneCommentRequest,
xmlns: &str,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name).default_ns(xmlns))?;
if let Some(ref value) = obj.comment {
&ResourceDescriptionSerializer::serialize(&mut writer, "Comment", value)?;
}
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct UpdateHostedZoneCommentResponse {
pub hosted_zone: HostedZone,
}
struct UpdateHostedZoneCommentResponseDeserializer;
impl UpdateHostedZoneCommentResponseDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<UpdateHostedZoneCommentResponse, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = UpdateHostedZoneCommentResponse::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[..] {
"HostedZone" => {
obj.hosted_zone = HostedZoneDeserializer::deserialize("HostedZone", stack)?;
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct UpdateTrafficPolicyCommentRequest {
pub comment: String,
pub id: String,
pub version: i64,
}
pub struct UpdateTrafficPolicyCommentRequestSerializer;
impl UpdateTrafficPolicyCommentRequestSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &UpdateTrafficPolicyCommentRequest,
xmlns: &str,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name).default_ns(xmlns))?;
TrafficPolicyCommentSerializer::serialize(&mut writer, "Comment", &obj.comment)?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct UpdateTrafficPolicyCommentResponse {
pub traffic_policy: TrafficPolicy,
}
struct UpdateTrafficPolicyCommentResponseDeserializer;
impl UpdateTrafficPolicyCommentResponseDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<UpdateTrafficPolicyCommentResponse, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = UpdateTrafficPolicyCommentResponse::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[..] {
"TrafficPolicy" => {
obj.traffic_policy =
TrafficPolicyDeserializer::deserialize("TrafficPolicy", stack)?;
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct UpdateTrafficPolicyInstanceRequest {
pub id: String,
pub ttl: i64,
pub traffic_policy_id: String,
pub traffic_policy_version: i64,
}
pub struct UpdateTrafficPolicyInstanceRequestSerializer;
impl UpdateTrafficPolicyInstanceRequestSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &UpdateTrafficPolicyInstanceRequest,
xmlns: &str,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name).default_ns(xmlns))?;
TTLSerializer::serialize(&mut writer, "TTL", &obj.ttl)?;
TrafficPolicyIdSerializer::serialize(
&mut writer,
"TrafficPolicyId",
&obj.traffic_policy_id,
)?;
TrafficPolicyVersionSerializer::serialize(
&mut writer,
"TrafficPolicyVersion",
&obj.traffic_policy_version,
)?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct UpdateTrafficPolicyInstanceResponse {
pub traffic_policy_instance: TrafficPolicyInstance,
}
struct UpdateTrafficPolicyInstanceResponseDeserializer;
impl UpdateTrafficPolicyInstanceResponseDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<UpdateTrafficPolicyInstanceResponse, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = UpdateTrafficPolicyInstanceResponse::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[..] {
"TrafficPolicyInstance" => {
obj.traffic_policy_instance =
TrafficPolicyInstanceDeserializer::deserialize(
"TrafficPolicyInstance",
stack,
)?;
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct UsageCountDeserializer;
impl UsageCountDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<i64, XmlParseError> {
start_element(tag_name, stack)?;
let obj = i64::from_str(characters(stack)?.as_ref()).unwrap();
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct VPC {
pub vpc_id: Option<String>,
pub vpc_region: Option<String>,
}
struct VPCDeserializer;
impl VPCDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<VPC, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = VPC::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[..] {
"VPCId" => {
obj.vpc_id = Some(VPCIdDeserializer::deserialize("VPCId", stack)?);
}
"VPCRegion" => {
obj.vpc_region =
Some(VPCRegionDeserializer::deserialize("VPCRegion", stack)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
pub struct VPCSerializer;
impl VPCSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &VPC,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
if let Some(ref value) = obj.vpc_id {
writer.write(xml::writer::XmlEvent::start_element("VPCId"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = value
)));
writer.write(xml::writer::XmlEvent::end_element())?;
}
if let Some(ref value) = obj.vpc_region {
writer.write(xml::writer::XmlEvent::start_element("VPCRegion"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = value
)));
writer.write(xml::writer::XmlEvent::end_element())?;
}
writer.write(xml::writer::XmlEvent::end_element())
}
}
struct VPCIdDeserializer;
impl VPCIdDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
pub struct VPCIdSerializer;
impl VPCIdSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &String,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.to_string()
)))?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
struct VPCRegionDeserializer;
impl VPCRegionDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
pub struct VPCRegionSerializer;
impl VPCRegionSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &String,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.to_string()
)))?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
struct VPCsDeserializer;
impl VPCsDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<VPC>, XmlParseError> {
let mut obj = vec![];
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 == "VPC" {
obj.push(VPCDeserializer::deserialize("VPC", stack)?);
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
end_element(tag_name, stack)?;
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
#[derive(Debug, PartialEq)]
pub enum AssociateVPCWithHostedZoneError {
ConflictingDomainExists(String),
InvalidInput(String),
InvalidVPCId(String),
LimitsExceeded(String),
NoSuchHostedZone(String),
NotAuthorized(String),
PublicZoneVPCAssociation(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl AssociateVPCWithHostedZoneError {
pub fn from_response(res: BufferedHttpResponse) -> AssociateVPCWithHostedZoneError {
{
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[..] {
"ConflictingDomainExists" => {
return AssociateVPCWithHostedZoneError::ConflictingDomainExists(
String::from(parsed_error.message),
);
}
"InvalidInput" => {
return AssociateVPCWithHostedZoneError::InvalidInput(String::from(
parsed_error.message,
));
}
"InvalidVPCId" => {
return AssociateVPCWithHostedZoneError::InvalidVPCId(String::from(
parsed_error.message,
));
}
"LimitsExceeded" => {
return AssociateVPCWithHostedZoneError::LimitsExceeded(String::from(
parsed_error.message,
));
}
"NoSuchHostedZone" => {
return AssociateVPCWithHostedZoneError::NoSuchHostedZone(String::from(
parsed_error.message,
));
}
"NotAuthorizedException" => {
return AssociateVPCWithHostedZoneError::NotAuthorized(String::from(
parsed_error.message,
));
}
"PublicZoneVPCAssociation" => {
return AssociateVPCWithHostedZoneError::PublicZoneVPCAssociation(
String::from(parsed_error.message),
);
}
_ => {}
}
}
}
AssociateVPCWithHostedZoneError::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 AssociateVPCWithHostedZoneError {
fn from(err: XmlParseError) -> AssociateVPCWithHostedZoneError {
let XmlParseError(message) = err;
AssociateVPCWithHostedZoneError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for AssociateVPCWithHostedZoneError {
fn from(err: CredentialsError) -> AssociateVPCWithHostedZoneError {
AssociateVPCWithHostedZoneError::Credentials(err)
}
}
impl From<HttpDispatchError> for AssociateVPCWithHostedZoneError {
fn from(err: HttpDispatchError) -> AssociateVPCWithHostedZoneError {
AssociateVPCWithHostedZoneError::HttpDispatch(err)
}
}
impl From<io::Error> for AssociateVPCWithHostedZoneError {
fn from(err: io::Error) -> AssociateVPCWithHostedZoneError {
AssociateVPCWithHostedZoneError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for AssociateVPCWithHostedZoneError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for AssociateVPCWithHostedZoneError {
fn description(&self) -> &str {
match *self {
AssociateVPCWithHostedZoneError::ConflictingDomainExists(ref cause) => cause,
AssociateVPCWithHostedZoneError::InvalidInput(ref cause) => cause,
AssociateVPCWithHostedZoneError::InvalidVPCId(ref cause) => cause,
AssociateVPCWithHostedZoneError::LimitsExceeded(ref cause) => cause,
AssociateVPCWithHostedZoneError::NoSuchHostedZone(ref cause) => cause,
AssociateVPCWithHostedZoneError::NotAuthorized(ref cause) => cause,
AssociateVPCWithHostedZoneError::PublicZoneVPCAssociation(ref cause) => cause,
AssociateVPCWithHostedZoneError::Validation(ref cause) => cause,
AssociateVPCWithHostedZoneError::Credentials(ref err) => err.description(),
AssociateVPCWithHostedZoneError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
AssociateVPCWithHostedZoneError::ParseError(ref cause) => cause,
AssociateVPCWithHostedZoneError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ChangeResourceRecordSetsError {
InvalidChangeBatch(String),
InvalidInput(String),
NoSuchHealthCheck(String),
NoSuchHostedZone(String),
PriorRequestNotComplete(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ChangeResourceRecordSetsError {
pub fn from_response(res: BufferedHttpResponse) -> ChangeResourceRecordSetsError {
{
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[..] {
"InvalidChangeBatch" => {
return ChangeResourceRecordSetsError::InvalidChangeBatch(String::from(
parsed_error.message,
));
}
"InvalidInput" => {
return ChangeResourceRecordSetsError::InvalidInput(String::from(
parsed_error.message,
));
}
"NoSuchHealthCheck" => {
return ChangeResourceRecordSetsError::NoSuchHealthCheck(String::from(
parsed_error.message,
));
}
"NoSuchHostedZone" => {
return ChangeResourceRecordSetsError::NoSuchHostedZone(String::from(
parsed_error.message,
));
}
"PriorRequestNotComplete" => {
return ChangeResourceRecordSetsError::PriorRequestNotComplete(String::from(
parsed_error.message,
));
}
_ => {}
}
}
}
ChangeResourceRecordSetsError::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 ChangeResourceRecordSetsError {
fn from(err: XmlParseError) -> ChangeResourceRecordSetsError {
let XmlParseError(message) = err;
ChangeResourceRecordSetsError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for ChangeResourceRecordSetsError {
fn from(err: CredentialsError) -> ChangeResourceRecordSetsError {
ChangeResourceRecordSetsError::Credentials(err)
}
}
impl From<HttpDispatchError> for ChangeResourceRecordSetsError {
fn from(err: HttpDispatchError) -> ChangeResourceRecordSetsError {
ChangeResourceRecordSetsError::HttpDispatch(err)
}
}
impl From<io::Error> for ChangeResourceRecordSetsError {
fn from(err: io::Error) -> ChangeResourceRecordSetsError {
ChangeResourceRecordSetsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ChangeResourceRecordSetsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ChangeResourceRecordSetsError {
fn description(&self) -> &str {
match *self {
ChangeResourceRecordSetsError::InvalidChangeBatch(ref cause) => cause,
ChangeResourceRecordSetsError::InvalidInput(ref cause) => cause,
ChangeResourceRecordSetsError::NoSuchHealthCheck(ref cause) => cause,
ChangeResourceRecordSetsError::NoSuchHostedZone(ref cause) => cause,
ChangeResourceRecordSetsError::PriorRequestNotComplete(ref cause) => cause,
ChangeResourceRecordSetsError::Validation(ref cause) => cause,
ChangeResourceRecordSetsError::Credentials(ref err) => err.description(),
ChangeResourceRecordSetsError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
ChangeResourceRecordSetsError::ParseError(ref cause) => cause,
ChangeResourceRecordSetsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ChangeTagsForResourceError {
InvalidInput(String),
NoSuchHealthCheck(String),
NoSuchHostedZone(String),
PriorRequestNotComplete(String),
Throttling(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ChangeTagsForResourceError {
pub fn from_response(res: BufferedHttpResponse) -> ChangeTagsForResourceError {
{
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[..] {
"InvalidInput" => {
return ChangeTagsForResourceError::InvalidInput(String::from(
parsed_error.message,
));
}
"NoSuchHealthCheck" => {
return ChangeTagsForResourceError::NoSuchHealthCheck(String::from(
parsed_error.message,
));
}
"NoSuchHostedZone" => {
return ChangeTagsForResourceError::NoSuchHostedZone(String::from(
parsed_error.message,
));
}
"PriorRequestNotComplete" => {
return ChangeTagsForResourceError::PriorRequestNotComplete(String::from(
parsed_error.message,
));
}
"ThrottlingException" => {
return ChangeTagsForResourceError::Throttling(String::from(
parsed_error.message,
));
}
_ => {}
}
}
}
ChangeTagsForResourceError::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 ChangeTagsForResourceError {
fn from(err: XmlParseError) -> ChangeTagsForResourceError {
let XmlParseError(message) = err;
ChangeTagsForResourceError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for ChangeTagsForResourceError {
fn from(err: CredentialsError) -> ChangeTagsForResourceError {
ChangeTagsForResourceError::Credentials(err)
}
}
impl From<HttpDispatchError> for ChangeTagsForResourceError {
fn from(err: HttpDispatchError) -> ChangeTagsForResourceError {
ChangeTagsForResourceError::HttpDispatch(err)
}
}
impl From<io::Error> for ChangeTagsForResourceError {
fn from(err: io::Error) -> ChangeTagsForResourceError {
ChangeTagsForResourceError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ChangeTagsForResourceError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ChangeTagsForResourceError {
fn description(&self) -> &str {
match *self {
ChangeTagsForResourceError::InvalidInput(ref cause) => cause,
ChangeTagsForResourceError::NoSuchHealthCheck(ref cause) => cause,
ChangeTagsForResourceError::NoSuchHostedZone(ref cause) => cause,
ChangeTagsForResourceError::PriorRequestNotComplete(ref cause) => cause,
ChangeTagsForResourceError::Throttling(ref cause) => cause,
ChangeTagsForResourceError::Validation(ref cause) => cause,
ChangeTagsForResourceError::Credentials(ref err) => err.description(),
ChangeTagsForResourceError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
ChangeTagsForResourceError::ParseError(ref cause) => cause,
ChangeTagsForResourceError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateHealthCheckError {
HealthCheckAlreadyExists(String),
InvalidInput(String),
TooManyHealthChecks(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CreateHealthCheckError {
pub fn from_response(res: BufferedHttpResponse) -> CreateHealthCheckError {
{
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[..] {
"HealthCheckAlreadyExists" => {
return CreateHealthCheckError::HealthCheckAlreadyExists(String::from(
parsed_error.message,
));
}
"InvalidInput" => {
return CreateHealthCheckError::InvalidInput(String::from(
parsed_error.message,
));
}
"TooManyHealthChecks" => {
return CreateHealthCheckError::TooManyHealthChecks(String::from(
parsed_error.message,
));
}
_ => {}
}
}
}
CreateHealthCheckError::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 CreateHealthCheckError {
fn from(err: XmlParseError) -> CreateHealthCheckError {
let XmlParseError(message) = err;
CreateHealthCheckError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for CreateHealthCheckError {
fn from(err: CredentialsError) -> CreateHealthCheckError {
CreateHealthCheckError::Credentials(err)
}
}
impl From<HttpDispatchError> for CreateHealthCheckError {
fn from(err: HttpDispatchError) -> CreateHealthCheckError {
CreateHealthCheckError::HttpDispatch(err)
}
}
impl From<io::Error> for CreateHealthCheckError {
fn from(err: io::Error) -> CreateHealthCheckError {
CreateHealthCheckError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CreateHealthCheckError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateHealthCheckError {
fn description(&self) -> &str {
match *self {
CreateHealthCheckError::HealthCheckAlreadyExists(ref cause) => cause,
CreateHealthCheckError::InvalidInput(ref cause) => cause,
CreateHealthCheckError::TooManyHealthChecks(ref cause) => cause,
CreateHealthCheckError::Validation(ref cause) => cause,
CreateHealthCheckError::Credentials(ref err) => err.description(),
CreateHealthCheckError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
CreateHealthCheckError::ParseError(ref cause) => cause,
CreateHealthCheckError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateHostedZoneError {
ConflictingDomainExists(String),
DelegationSetNotAvailable(String),
DelegationSetNotReusable(String),
HostedZoneAlreadyExists(String),
InvalidDomainName(String),
InvalidInput(String),
InvalidVPCId(String),
NoSuchDelegationSet(String),
TooManyHostedZones(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CreateHostedZoneError {
pub fn from_response(res: BufferedHttpResponse) -> CreateHostedZoneError {
{
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[..] {
"ConflictingDomainExists" => {
return CreateHostedZoneError::ConflictingDomainExists(String::from(
parsed_error.message,
));
}
"DelegationSetNotAvailable" => {
return CreateHostedZoneError::DelegationSetNotAvailable(String::from(
parsed_error.message,
));
}
"DelegationSetNotReusable" => {
return CreateHostedZoneError::DelegationSetNotReusable(String::from(
parsed_error.message,
));
}
"HostedZoneAlreadyExists" => {
return CreateHostedZoneError::HostedZoneAlreadyExists(String::from(
parsed_error.message,
));
}
"InvalidDomainName" => {
return CreateHostedZoneError::InvalidDomainName(String::from(
parsed_error.message,
));
}
"InvalidInput" => {
return CreateHostedZoneError::InvalidInput(String::from(
parsed_error.message,
));
}
"InvalidVPCId" => {
return CreateHostedZoneError::InvalidVPCId(String::from(
parsed_error.message,
));
}
"NoSuchDelegationSet" => {
return CreateHostedZoneError::NoSuchDelegationSet(String::from(
parsed_error.message,
));
}
"TooManyHostedZones" => {
return CreateHostedZoneError::TooManyHostedZones(String::from(
parsed_error.message,
));
}
_ => {}
}
}
}
CreateHostedZoneError::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 CreateHostedZoneError {
fn from(err: XmlParseError) -> CreateHostedZoneError {
let XmlParseError(message) = err;
CreateHostedZoneError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for CreateHostedZoneError {
fn from(err: CredentialsError) -> CreateHostedZoneError {
CreateHostedZoneError::Credentials(err)
}
}
impl From<HttpDispatchError> for CreateHostedZoneError {
fn from(err: HttpDispatchError) -> CreateHostedZoneError {
CreateHostedZoneError::HttpDispatch(err)
}
}
impl From<io::Error> for CreateHostedZoneError {
fn from(err: io::Error) -> CreateHostedZoneError {
CreateHostedZoneError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CreateHostedZoneError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateHostedZoneError {
fn description(&self) -> &str {
match *self {
CreateHostedZoneError::ConflictingDomainExists(ref cause) => cause,
CreateHostedZoneError::DelegationSetNotAvailable(ref cause) => cause,
CreateHostedZoneError::DelegationSetNotReusable(ref cause) => cause,
CreateHostedZoneError::HostedZoneAlreadyExists(ref cause) => cause,
CreateHostedZoneError::InvalidDomainName(ref cause) => cause,
CreateHostedZoneError::InvalidInput(ref cause) => cause,
CreateHostedZoneError::InvalidVPCId(ref cause) => cause,
CreateHostedZoneError::NoSuchDelegationSet(ref cause) => cause,
CreateHostedZoneError::TooManyHostedZones(ref cause) => cause,
CreateHostedZoneError::Validation(ref cause) => cause,
CreateHostedZoneError::Credentials(ref err) => err.description(),
CreateHostedZoneError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
CreateHostedZoneError::ParseError(ref cause) => cause,
CreateHostedZoneError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateQueryLoggingConfigError {
ConcurrentModification(String),
InsufficientCloudWatchLogsResourcePolicy(String),
InvalidInput(String),
NoSuchCloudWatchLogsLogGroup(String),
NoSuchHostedZone(String),
QueryLoggingConfigAlreadyExists(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CreateQueryLoggingConfigError {
pub fn from_response(res: BufferedHttpResponse) -> CreateQueryLoggingConfigError {
{
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[..] {
"ConcurrentModification" => return CreateQueryLoggingConfigError::ConcurrentModification(String::from(parsed_error.message)),"InsufficientCloudWatchLogsResourcePolicy" => return CreateQueryLoggingConfigError::InsufficientCloudWatchLogsResourcePolicy(String::from(parsed_error.message)),"InvalidInput" => return CreateQueryLoggingConfigError::InvalidInput(String::from(parsed_error.message)),"NoSuchCloudWatchLogsLogGroup" => return CreateQueryLoggingConfigError::NoSuchCloudWatchLogsLogGroup(String::from(parsed_error.message)),"NoSuchHostedZone" => return CreateQueryLoggingConfigError::NoSuchHostedZone(String::from(parsed_error.message)),"QueryLoggingConfigAlreadyExists" => return CreateQueryLoggingConfigError::QueryLoggingConfigAlreadyExists(String::from(parsed_error.message)),_ => {}
}
}
}
CreateQueryLoggingConfigError::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 CreateQueryLoggingConfigError {
fn from(err: XmlParseError) -> CreateQueryLoggingConfigError {
let XmlParseError(message) = err;
CreateQueryLoggingConfigError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for CreateQueryLoggingConfigError {
fn from(err: CredentialsError) -> CreateQueryLoggingConfigError {
CreateQueryLoggingConfigError::Credentials(err)
}
}
impl From<HttpDispatchError> for CreateQueryLoggingConfigError {
fn from(err: HttpDispatchError) -> CreateQueryLoggingConfigError {
CreateQueryLoggingConfigError::HttpDispatch(err)
}
}
impl From<io::Error> for CreateQueryLoggingConfigError {
fn from(err: io::Error) -> CreateQueryLoggingConfigError {
CreateQueryLoggingConfigError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CreateQueryLoggingConfigError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateQueryLoggingConfigError {
fn description(&self) -> &str {
match *self {
CreateQueryLoggingConfigError::ConcurrentModification(ref cause) => cause,
CreateQueryLoggingConfigError::InsufficientCloudWatchLogsResourcePolicy(ref cause) => {
cause
}
CreateQueryLoggingConfigError::InvalidInput(ref cause) => cause,
CreateQueryLoggingConfigError::NoSuchCloudWatchLogsLogGroup(ref cause) => cause,
CreateQueryLoggingConfigError::NoSuchHostedZone(ref cause) => cause,
CreateQueryLoggingConfigError::QueryLoggingConfigAlreadyExists(ref cause) => cause,
CreateQueryLoggingConfigError::Validation(ref cause) => cause,
CreateQueryLoggingConfigError::Credentials(ref err) => err.description(),
CreateQueryLoggingConfigError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
CreateQueryLoggingConfigError::ParseError(ref cause) => cause,
CreateQueryLoggingConfigError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateReusableDelegationSetError {
DelegationSetAlreadyCreated(String),
DelegationSetAlreadyReusable(String),
DelegationSetNotAvailable(String),
HostedZoneNotFound(String),
InvalidArgument(String),
InvalidInput(String),
LimitsExceeded(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CreateReusableDelegationSetError {
pub fn from_response(res: BufferedHttpResponse) -> CreateReusableDelegationSetError {
{
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[..] {
"DelegationSetAlreadyCreated" => {
return CreateReusableDelegationSetError::DelegationSetAlreadyCreated(
String::from(parsed_error.message),
);
}
"DelegationSetAlreadyReusable" => {
return CreateReusableDelegationSetError::DelegationSetAlreadyReusable(
String::from(parsed_error.message),
);
}
"DelegationSetNotAvailable" => {
return CreateReusableDelegationSetError::DelegationSetNotAvailable(
String::from(parsed_error.message),
);
}
"HostedZoneNotFound" => {
return CreateReusableDelegationSetError::HostedZoneNotFound(String::from(
parsed_error.message,
));
}
"InvalidArgument" => {
return CreateReusableDelegationSetError::InvalidArgument(String::from(
parsed_error.message,
));
}
"InvalidInput" => {
return CreateReusableDelegationSetError::InvalidInput(String::from(
parsed_error.message,
));
}
"LimitsExceeded" => {
return CreateReusableDelegationSetError::LimitsExceeded(String::from(
parsed_error.message,
));
}
_ => {}
}
}
}
CreateReusableDelegationSetError::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 CreateReusableDelegationSetError {
fn from(err: XmlParseError) -> CreateReusableDelegationSetError {
let XmlParseError(message) = err;
CreateReusableDelegationSetError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for CreateReusableDelegationSetError {
fn from(err: CredentialsError) -> CreateReusableDelegationSetError {
CreateReusableDelegationSetError::Credentials(err)
}
}
impl From<HttpDispatchError> for CreateReusableDelegationSetError {
fn from(err: HttpDispatchError) -> CreateReusableDelegationSetError {
CreateReusableDelegationSetError::HttpDispatch(err)
}
}
impl From<io::Error> for CreateReusableDelegationSetError {
fn from(err: io::Error) -> CreateReusableDelegationSetError {
CreateReusableDelegationSetError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CreateReusableDelegationSetError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateReusableDelegationSetError {
fn description(&self) -> &str {
match *self {
CreateReusableDelegationSetError::DelegationSetAlreadyCreated(ref cause) => cause,
CreateReusableDelegationSetError::DelegationSetAlreadyReusable(ref cause) => cause,
CreateReusableDelegationSetError::DelegationSetNotAvailable(ref cause) => cause,
CreateReusableDelegationSetError::HostedZoneNotFound(ref cause) => cause,
CreateReusableDelegationSetError::InvalidArgument(ref cause) => cause,
CreateReusableDelegationSetError::InvalidInput(ref cause) => cause,
CreateReusableDelegationSetError::LimitsExceeded(ref cause) => cause,
CreateReusableDelegationSetError::Validation(ref cause) => cause,
CreateReusableDelegationSetError::Credentials(ref err) => err.description(),
CreateReusableDelegationSetError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
CreateReusableDelegationSetError::ParseError(ref cause) => cause,
CreateReusableDelegationSetError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateTrafficPolicyError {
InvalidInput(String),
InvalidTrafficPolicyDocument(String),
TooManyTrafficPolicies(String),
TrafficPolicyAlreadyExists(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CreateTrafficPolicyError {
pub fn from_response(res: BufferedHttpResponse) -> CreateTrafficPolicyError {
{
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[..] {
"InvalidInput" => {
return CreateTrafficPolicyError::InvalidInput(String::from(
parsed_error.message,
));
}
"InvalidTrafficPolicyDocument" => {
return CreateTrafficPolicyError::InvalidTrafficPolicyDocument(String::from(
parsed_error.message,
));
}
"TooManyTrafficPolicies" => {
return CreateTrafficPolicyError::TooManyTrafficPolicies(String::from(
parsed_error.message,
));
}
"TrafficPolicyAlreadyExists" => {
return CreateTrafficPolicyError::TrafficPolicyAlreadyExists(String::from(
parsed_error.message,
));
}
_ => {}
}
}
}
CreateTrafficPolicyError::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 CreateTrafficPolicyError {
fn from(err: XmlParseError) -> CreateTrafficPolicyError {
let XmlParseError(message) = err;
CreateTrafficPolicyError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for CreateTrafficPolicyError {
fn from(err: CredentialsError) -> CreateTrafficPolicyError {
CreateTrafficPolicyError::Credentials(err)
}
}
impl From<HttpDispatchError> for CreateTrafficPolicyError {
fn from(err: HttpDispatchError) -> CreateTrafficPolicyError {
CreateTrafficPolicyError::HttpDispatch(err)
}
}
impl From<io::Error> for CreateTrafficPolicyError {
fn from(err: io::Error) -> CreateTrafficPolicyError {
CreateTrafficPolicyError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CreateTrafficPolicyError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateTrafficPolicyError {
fn description(&self) -> &str {
match *self {
CreateTrafficPolicyError::InvalidInput(ref cause) => cause,
CreateTrafficPolicyError::InvalidTrafficPolicyDocument(ref cause) => cause,
CreateTrafficPolicyError::TooManyTrafficPolicies(ref cause) => cause,
CreateTrafficPolicyError::TrafficPolicyAlreadyExists(ref cause) => cause,
CreateTrafficPolicyError::Validation(ref cause) => cause,
CreateTrafficPolicyError::Credentials(ref err) => err.description(),
CreateTrafficPolicyError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
CreateTrafficPolicyError::ParseError(ref cause) => cause,
CreateTrafficPolicyError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateTrafficPolicyInstanceError {
InvalidInput(String),
NoSuchHostedZone(String),
NoSuchTrafficPolicy(String),
TooManyTrafficPolicyInstances(String),
TrafficPolicyInstanceAlreadyExists(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CreateTrafficPolicyInstanceError {
pub fn from_response(res: BufferedHttpResponse) -> CreateTrafficPolicyInstanceError {
{
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[..] {
"InvalidInput" => {
return CreateTrafficPolicyInstanceError::InvalidInput(String::from(
parsed_error.message,
));
}
"NoSuchHostedZone" => {
return CreateTrafficPolicyInstanceError::NoSuchHostedZone(String::from(
parsed_error.message,
));
}
"NoSuchTrafficPolicy" => {
return CreateTrafficPolicyInstanceError::NoSuchTrafficPolicy(String::from(
parsed_error.message,
));
}
"TooManyTrafficPolicyInstances" => {
return CreateTrafficPolicyInstanceError::TooManyTrafficPolicyInstances(
String::from(parsed_error.message),
);
}
"TrafficPolicyInstanceAlreadyExists" => {
return CreateTrafficPolicyInstanceError::TrafficPolicyInstanceAlreadyExists(
String::from(parsed_error.message),
);
}
_ => {}
}
}
}
CreateTrafficPolicyInstanceError::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 CreateTrafficPolicyInstanceError {
fn from(err: XmlParseError) -> CreateTrafficPolicyInstanceError {
let XmlParseError(message) = err;
CreateTrafficPolicyInstanceError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for CreateTrafficPolicyInstanceError {
fn from(err: CredentialsError) -> CreateTrafficPolicyInstanceError {
CreateTrafficPolicyInstanceError::Credentials(err)
}
}
impl From<HttpDispatchError> for CreateTrafficPolicyInstanceError {
fn from(err: HttpDispatchError) -> CreateTrafficPolicyInstanceError {
CreateTrafficPolicyInstanceError::HttpDispatch(err)
}
}
impl From<io::Error> for CreateTrafficPolicyInstanceError {
fn from(err: io::Error) -> CreateTrafficPolicyInstanceError {
CreateTrafficPolicyInstanceError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CreateTrafficPolicyInstanceError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateTrafficPolicyInstanceError {
fn description(&self) -> &str {
match *self {
CreateTrafficPolicyInstanceError::InvalidInput(ref cause) => cause,
CreateTrafficPolicyInstanceError::NoSuchHostedZone(ref cause) => cause,
CreateTrafficPolicyInstanceError::NoSuchTrafficPolicy(ref cause) => cause,
CreateTrafficPolicyInstanceError::TooManyTrafficPolicyInstances(ref cause) => cause,
CreateTrafficPolicyInstanceError::TrafficPolicyInstanceAlreadyExists(ref cause) => {
cause
}
CreateTrafficPolicyInstanceError::Validation(ref cause) => cause,
CreateTrafficPolicyInstanceError::Credentials(ref err) => err.description(),
CreateTrafficPolicyInstanceError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
CreateTrafficPolicyInstanceError::ParseError(ref cause) => cause,
CreateTrafficPolicyInstanceError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateTrafficPolicyVersionError {
ConcurrentModification(String),
InvalidInput(String),
InvalidTrafficPolicyDocument(String),
NoSuchTrafficPolicy(String),
TooManyTrafficPolicyVersionsForCurrentPolicy(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CreateTrafficPolicyVersionError {
pub fn from_response(res: BufferedHttpResponse) -> CreateTrafficPolicyVersionError {
{
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[..] {
"ConcurrentModification" => return CreateTrafficPolicyVersionError::ConcurrentModification(String::from(parsed_error.message)),"InvalidInput" => return CreateTrafficPolicyVersionError::InvalidInput(String::from(parsed_error.message)),"InvalidTrafficPolicyDocument" => return CreateTrafficPolicyVersionError::InvalidTrafficPolicyDocument(String::from(parsed_error.message)),"NoSuchTrafficPolicy" => return CreateTrafficPolicyVersionError::NoSuchTrafficPolicy(String::from(parsed_error.message)),"TooManyTrafficPolicyVersionsForCurrentPolicy" => return CreateTrafficPolicyVersionError::TooManyTrafficPolicyVersionsForCurrentPolicy(String::from(parsed_error.message)),_ => {}
}
}
}
CreateTrafficPolicyVersionError::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 CreateTrafficPolicyVersionError {
fn from(err: XmlParseError) -> CreateTrafficPolicyVersionError {
let XmlParseError(message) = err;
CreateTrafficPolicyVersionError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for CreateTrafficPolicyVersionError {
fn from(err: CredentialsError) -> CreateTrafficPolicyVersionError {
CreateTrafficPolicyVersionError::Credentials(err)
}
}
impl From<HttpDispatchError> for CreateTrafficPolicyVersionError {
fn from(err: HttpDispatchError) -> CreateTrafficPolicyVersionError {
CreateTrafficPolicyVersionError::HttpDispatch(err)
}
}
impl From<io::Error> for CreateTrafficPolicyVersionError {
fn from(err: io::Error) -> CreateTrafficPolicyVersionError {
CreateTrafficPolicyVersionError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CreateTrafficPolicyVersionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateTrafficPolicyVersionError {
fn description(&self) -> &str {
match *self {
CreateTrafficPolicyVersionError::ConcurrentModification(ref cause) => cause,
CreateTrafficPolicyVersionError::InvalidInput(ref cause) => cause,
CreateTrafficPolicyVersionError::InvalidTrafficPolicyDocument(ref cause) => cause,
CreateTrafficPolicyVersionError::NoSuchTrafficPolicy(ref cause) => cause,
CreateTrafficPolicyVersionError::TooManyTrafficPolicyVersionsForCurrentPolicy(
ref cause,
) => cause,
CreateTrafficPolicyVersionError::Validation(ref cause) => cause,
CreateTrafficPolicyVersionError::Credentials(ref err) => err.description(),
CreateTrafficPolicyVersionError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
CreateTrafficPolicyVersionError::ParseError(ref cause) => cause,
CreateTrafficPolicyVersionError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateVPCAssociationAuthorizationError {
ConcurrentModification(String),
InvalidInput(String),
InvalidVPCId(String),
NoSuchHostedZone(String),
TooManyVPCAssociationAuthorizations(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CreateVPCAssociationAuthorizationError {
pub fn from_response(res: BufferedHttpResponse) -> CreateVPCAssociationAuthorizationError {
{
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[..] {
"ConcurrentModification" => return CreateVPCAssociationAuthorizationError::ConcurrentModification(String::from(parsed_error.message)),"InvalidInput" => return CreateVPCAssociationAuthorizationError::InvalidInput(String::from(parsed_error.message)),"InvalidVPCId" => return CreateVPCAssociationAuthorizationError::InvalidVPCId(String::from(parsed_error.message)),"NoSuchHostedZone" => return CreateVPCAssociationAuthorizationError::NoSuchHostedZone(String::from(parsed_error.message)),"TooManyVPCAssociationAuthorizations" => return CreateVPCAssociationAuthorizationError::TooManyVPCAssociationAuthorizations(String::from(parsed_error.message)),_ => {}
}
}
}
CreateVPCAssociationAuthorizationError::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 CreateVPCAssociationAuthorizationError {
fn from(err: XmlParseError) -> CreateVPCAssociationAuthorizationError {
let XmlParseError(message) = err;
CreateVPCAssociationAuthorizationError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for CreateVPCAssociationAuthorizationError {
fn from(err: CredentialsError) -> CreateVPCAssociationAuthorizationError {
CreateVPCAssociationAuthorizationError::Credentials(err)
}
}
impl From<HttpDispatchError> for CreateVPCAssociationAuthorizationError {
fn from(err: HttpDispatchError) -> CreateVPCAssociationAuthorizationError {
CreateVPCAssociationAuthorizationError::HttpDispatch(err)
}
}
impl From<io::Error> for CreateVPCAssociationAuthorizationError {
fn from(err: io::Error) -> CreateVPCAssociationAuthorizationError {
CreateVPCAssociationAuthorizationError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CreateVPCAssociationAuthorizationError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateVPCAssociationAuthorizationError {
fn description(&self) -> &str {
match *self {
CreateVPCAssociationAuthorizationError::ConcurrentModification(ref cause) => cause,
CreateVPCAssociationAuthorizationError::InvalidInput(ref cause) => cause,
CreateVPCAssociationAuthorizationError::InvalidVPCId(ref cause) => cause,
CreateVPCAssociationAuthorizationError::NoSuchHostedZone(ref cause) => cause,
CreateVPCAssociationAuthorizationError::TooManyVPCAssociationAuthorizations(
ref cause,
) => cause,
CreateVPCAssociationAuthorizationError::Validation(ref cause) => cause,
CreateVPCAssociationAuthorizationError::Credentials(ref err) => err.description(),
CreateVPCAssociationAuthorizationError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
CreateVPCAssociationAuthorizationError::ParseError(ref cause) => cause,
CreateVPCAssociationAuthorizationError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteHealthCheckError {
HealthCheckInUse(String),
InvalidInput(String),
NoSuchHealthCheck(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DeleteHealthCheckError {
pub fn from_response(res: BufferedHttpResponse) -> DeleteHealthCheckError {
{
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[..] {
"HealthCheckInUse" => {
return DeleteHealthCheckError::HealthCheckInUse(String::from(
parsed_error.message,
));
}
"InvalidInput" => {
return DeleteHealthCheckError::InvalidInput(String::from(
parsed_error.message,
));
}
"NoSuchHealthCheck" => {
return DeleteHealthCheckError::NoSuchHealthCheck(String::from(
parsed_error.message,
));
}
_ => {}
}
}
}
DeleteHealthCheckError::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 DeleteHealthCheckError {
fn from(err: XmlParseError) -> DeleteHealthCheckError {
let XmlParseError(message) = err;
DeleteHealthCheckError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DeleteHealthCheckError {
fn from(err: CredentialsError) -> DeleteHealthCheckError {
DeleteHealthCheckError::Credentials(err)
}
}
impl From<HttpDispatchError> for DeleteHealthCheckError {
fn from(err: HttpDispatchError) -> DeleteHealthCheckError {
DeleteHealthCheckError::HttpDispatch(err)
}
}
impl From<io::Error> for DeleteHealthCheckError {
fn from(err: io::Error) -> DeleteHealthCheckError {
DeleteHealthCheckError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DeleteHealthCheckError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteHealthCheckError {
fn description(&self) -> &str {
match *self {
DeleteHealthCheckError::HealthCheckInUse(ref cause) => cause,
DeleteHealthCheckError::InvalidInput(ref cause) => cause,
DeleteHealthCheckError::NoSuchHealthCheck(ref cause) => cause,
DeleteHealthCheckError::Validation(ref cause) => cause,
DeleteHealthCheckError::Credentials(ref err) => err.description(),
DeleteHealthCheckError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DeleteHealthCheckError::ParseError(ref cause) => cause,
DeleteHealthCheckError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteHostedZoneError {
HostedZoneNotEmpty(String),
InvalidDomainName(String),
InvalidInput(String),
NoSuchHostedZone(String),
PriorRequestNotComplete(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DeleteHostedZoneError {
pub fn from_response(res: BufferedHttpResponse) -> DeleteHostedZoneError {
{
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[..] {
"HostedZoneNotEmpty" => {
return DeleteHostedZoneError::HostedZoneNotEmpty(String::from(
parsed_error.message,
));
}
"InvalidDomainName" => {
return DeleteHostedZoneError::InvalidDomainName(String::from(
parsed_error.message,
));
}
"InvalidInput" => {
return DeleteHostedZoneError::InvalidInput(String::from(
parsed_error.message,
));
}
"NoSuchHostedZone" => {
return DeleteHostedZoneError::NoSuchHostedZone(String::from(
parsed_error.message,
));
}
"PriorRequestNotComplete" => {
return DeleteHostedZoneError::PriorRequestNotComplete(String::from(
parsed_error.message,
));
}
_ => {}
}
}
}
DeleteHostedZoneError::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 DeleteHostedZoneError {
fn from(err: XmlParseError) -> DeleteHostedZoneError {
let XmlParseError(message) = err;
DeleteHostedZoneError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DeleteHostedZoneError {
fn from(err: CredentialsError) -> DeleteHostedZoneError {
DeleteHostedZoneError::Credentials(err)
}
}
impl From<HttpDispatchError> for DeleteHostedZoneError {
fn from(err: HttpDispatchError) -> DeleteHostedZoneError {
DeleteHostedZoneError::HttpDispatch(err)
}
}
impl From<io::Error> for DeleteHostedZoneError {
fn from(err: io::Error) -> DeleteHostedZoneError {
DeleteHostedZoneError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DeleteHostedZoneError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteHostedZoneError {
fn description(&self) -> &str {
match *self {
DeleteHostedZoneError::HostedZoneNotEmpty(ref cause) => cause,
DeleteHostedZoneError::InvalidDomainName(ref cause) => cause,
DeleteHostedZoneError::InvalidInput(ref cause) => cause,
DeleteHostedZoneError::NoSuchHostedZone(ref cause) => cause,
DeleteHostedZoneError::PriorRequestNotComplete(ref cause) => cause,
DeleteHostedZoneError::Validation(ref cause) => cause,
DeleteHostedZoneError::Credentials(ref err) => err.description(),
DeleteHostedZoneError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
DeleteHostedZoneError::ParseError(ref cause) => cause,
DeleteHostedZoneError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteQueryLoggingConfigError {
ConcurrentModification(String),
InvalidInput(String),
NoSuchQueryLoggingConfig(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DeleteQueryLoggingConfigError {
pub fn from_response(res: BufferedHttpResponse) -> DeleteQueryLoggingConfigError {
{
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[..] {
"ConcurrentModification" => {
return DeleteQueryLoggingConfigError::ConcurrentModification(String::from(
parsed_error.message,
));
}
"InvalidInput" => {
return DeleteQueryLoggingConfigError::InvalidInput(String::from(
parsed_error.message,
));
}
"NoSuchQueryLoggingConfig" => {
return DeleteQueryLoggingConfigError::NoSuchQueryLoggingConfig(
String::from(parsed_error.message),
);
}
_ => {}
}
}
}
DeleteQueryLoggingConfigError::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 DeleteQueryLoggingConfigError {
fn from(err: XmlParseError) -> DeleteQueryLoggingConfigError {
let XmlParseError(message) = err;
DeleteQueryLoggingConfigError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DeleteQueryLoggingConfigError {
fn from(err: CredentialsError) -> DeleteQueryLoggingConfigError {
DeleteQueryLoggingConfigError::Credentials(err)
}
}
impl From<HttpDispatchError> for DeleteQueryLoggingConfigError {
fn from(err: HttpDispatchError) -> DeleteQueryLoggingConfigError {
DeleteQueryLoggingConfigError::HttpDispatch(err)
}
}
impl From<io::Error> for DeleteQueryLoggingConfigError {
fn from(err: io::Error) -> DeleteQueryLoggingConfigError {
DeleteQueryLoggingConfigError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DeleteQueryLoggingConfigError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteQueryLoggingConfigError {
fn description(&self) -> &str {
match *self {
DeleteQueryLoggingConfigError::ConcurrentModification(ref cause) => cause,
DeleteQueryLoggingConfigError::InvalidInput(ref cause) => cause,
DeleteQueryLoggingConfigError::NoSuchQueryLoggingConfig(ref cause) => cause,
DeleteQueryLoggingConfigError::Validation(ref cause) => cause,
DeleteQueryLoggingConfigError::Credentials(ref err) => err.description(),
DeleteQueryLoggingConfigError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DeleteQueryLoggingConfigError::ParseError(ref cause) => cause,
DeleteQueryLoggingConfigError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteReusableDelegationSetError {
DelegationSetInUse(String),
DelegationSetNotReusable(String),
InvalidInput(String),
NoSuchDelegationSet(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DeleteReusableDelegationSetError {
pub fn from_response(res: BufferedHttpResponse) -> DeleteReusableDelegationSetError {
{
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[..] {
"DelegationSetInUse" => {
return DeleteReusableDelegationSetError::DelegationSetInUse(String::from(
parsed_error.message,
));
}
"DelegationSetNotReusable" => {
return DeleteReusableDelegationSetError::DelegationSetNotReusable(
String::from(parsed_error.message),
);
}
"InvalidInput" => {
return DeleteReusableDelegationSetError::InvalidInput(String::from(
parsed_error.message,
));
}
"NoSuchDelegationSet" => {
return DeleteReusableDelegationSetError::NoSuchDelegationSet(String::from(
parsed_error.message,
));
}
_ => {}
}
}
}
DeleteReusableDelegationSetError::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 DeleteReusableDelegationSetError {
fn from(err: XmlParseError) -> DeleteReusableDelegationSetError {
let XmlParseError(message) = err;
DeleteReusableDelegationSetError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DeleteReusableDelegationSetError {
fn from(err: CredentialsError) -> DeleteReusableDelegationSetError {
DeleteReusableDelegationSetError::Credentials(err)
}
}
impl From<HttpDispatchError> for DeleteReusableDelegationSetError {
fn from(err: HttpDispatchError) -> DeleteReusableDelegationSetError {
DeleteReusableDelegationSetError::HttpDispatch(err)
}
}
impl From<io::Error> for DeleteReusableDelegationSetError {
fn from(err: io::Error) -> DeleteReusableDelegationSetError {
DeleteReusableDelegationSetError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DeleteReusableDelegationSetError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteReusableDelegationSetError {
fn description(&self) -> &str {
match *self {
DeleteReusableDelegationSetError::DelegationSetInUse(ref cause) => cause,
DeleteReusableDelegationSetError::DelegationSetNotReusable(ref cause) => cause,
DeleteReusableDelegationSetError::InvalidInput(ref cause) => cause,
DeleteReusableDelegationSetError::NoSuchDelegationSet(ref cause) => cause,
DeleteReusableDelegationSetError::Validation(ref cause) => cause,
DeleteReusableDelegationSetError::Credentials(ref err) => err.description(),
DeleteReusableDelegationSetError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DeleteReusableDelegationSetError::ParseError(ref cause) => cause,
DeleteReusableDelegationSetError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteTrafficPolicyError {
ConcurrentModification(String),
InvalidInput(String),
NoSuchTrafficPolicy(String),
TrafficPolicyInUse(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DeleteTrafficPolicyError {
pub fn from_response(res: BufferedHttpResponse) -> DeleteTrafficPolicyError {
{
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[..] {
"ConcurrentModification" => {
return DeleteTrafficPolicyError::ConcurrentModification(String::from(
parsed_error.message,
));
}
"InvalidInput" => {
return DeleteTrafficPolicyError::InvalidInput(String::from(
parsed_error.message,
));
}
"NoSuchTrafficPolicy" => {
return DeleteTrafficPolicyError::NoSuchTrafficPolicy(String::from(
parsed_error.message,
));
}
"TrafficPolicyInUse" => {
return DeleteTrafficPolicyError::TrafficPolicyInUse(String::from(
parsed_error.message,
));
}
_ => {}
}
}
}
DeleteTrafficPolicyError::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 DeleteTrafficPolicyError {
fn from(err: XmlParseError) -> DeleteTrafficPolicyError {
let XmlParseError(message) = err;
DeleteTrafficPolicyError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DeleteTrafficPolicyError {
fn from(err: CredentialsError) -> DeleteTrafficPolicyError {
DeleteTrafficPolicyError::Credentials(err)
}
}
impl From<HttpDispatchError> for DeleteTrafficPolicyError {
fn from(err: HttpDispatchError) -> DeleteTrafficPolicyError {
DeleteTrafficPolicyError::HttpDispatch(err)
}
}
impl From<io::Error> for DeleteTrafficPolicyError {
fn from(err: io::Error) -> DeleteTrafficPolicyError {
DeleteTrafficPolicyError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DeleteTrafficPolicyError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteTrafficPolicyError {
fn description(&self) -> &str {
match *self {
DeleteTrafficPolicyError::ConcurrentModification(ref cause) => cause,
DeleteTrafficPolicyError::InvalidInput(ref cause) => cause,
DeleteTrafficPolicyError::NoSuchTrafficPolicy(ref cause) => cause,
DeleteTrafficPolicyError::TrafficPolicyInUse(ref cause) => cause,
DeleteTrafficPolicyError::Validation(ref cause) => cause,
DeleteTrafficPolicyError::Credentials(ref err) => err.description(),
DeleteTrafficPolicyError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DeleteTrafficPolicyError::ParseError(ref cause) => cause,
DeleteTrafficPolicyError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteTrafficPolicyInstanceError {
InvalidInput(String),
NoSuchTrafficPolicyInstance(String),
PriorRequestNotComplete(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DeleteTrafficPolicyInstanceError {
pub fn from_response(res: BufferedHttpResponse) -> DeleteTrafficPolicyInstanceError {
{
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[..] {
"InvalidInput" => {
return DeleteTrafficPolicyInstanceError::InvalidInput(String::from(
parsed_error.message,
));
}
"NoSuchTrafficPolicyInstance" => {
return DeleteTrafficPolicyInstanceError::NoSuchTrafficPolicyInstance(
String::from(parsed_error.message),
);
}
"PriorRequestNotComplete" => {
return DeleteTrafficPolicyInstanceError::PriorRequestNotComplete(
String::from(parsed_error.message),
);
}
_ => {}
}
}
}
DeleteTrafficPolicyInstanceError::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 DeleteTrafficPolicyInstanceError {
fn from(err: XmlParseError) -> DeleteTrafficPolicyInstanceError {
let XmlParseError(message) = err;
DeleteTrafficPolicyInstanceError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DeleteTrafficPolicyInstanceError {
fn from(err: CredentialsError) -> DeleteTrafficPolicyInstanceError {
DeleteTrafficPolicyInstanceError::Credentials(err)
}
}
impl From<HttpDispatchError> for DeleteTrafficPolicyInstanceError {
fn from(err: HttpDispatchError) -> DeleteTrafficPolicyInstanceError {
DeleteTrafficPolicyInstanceError::HttpDispatch(err)
}
}
impl From<io::Error> for DeleteTrafficPolicyInstanceError {
fn from(err: io::Error) -> DeleteTrafficPolicyInstanceError {
DeleteTrafficPolicyInstanceError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DeleteTrafficPolicyInstanceError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteTrafficPolicyInstanceError {
fn description(&self) -> &str {
match *self {
DeleteTrafficPolicyInstanceError::InvalidInput(ref cause) => cause,
DeleteTrafficPolicyInstanceError::NoSuchTrafficPolicyInstance(ref cause) => cause,
DeleteTrafficPolicyInstanceError::PriorRequestNotComplete(ref cause) => cause,
DeleteTrafficPolicyInstanceError::Validation(ref cause) => cause,
DeleteTrafficPolicyInstanceError::Credentials(ref err) => err.description(),
DeleteTrafficPolicyInstanceError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DeleteTrafficPolicyInstanceError::ParseError(ref cause) => cause,
DeleteTrafficPolicyInstanceError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteVPCAssociationAuthorizationError {
ConcurrentModification(String),
InvalidInput(String),
InvalidVPCId(String),
NoSuchHostedZone(String),
VPCAssociationAuthorizationNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DeleteVPCAssociationAuthorizationError {
pub fn from_response(res: BufferedHttpResponse) -> DeleteVPCAssociationAuthorizationError {
{
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[..] {
"ConcurrentModification" => return DeleteVPCAssociationAuthorizationError::ConcurrentModification(String::from(parsed_error.message)),"InvalidInput" => return DeleteVPCAssociationAuthorizationError::InvalidInput(String::from(parsed_error.message)),"InvalidVPCId" => return DeleteVPCAssociationAuthorizationError::InvalidVPCId(String::from(parsed_error.message)),"NoSuchHostedZone" => return DeleteVPCAssociationAuthorizationError::NoSuchHostedZone(String::from(parsed_error.message)),"VPCAssociationAuthorizationNotFound" => return DeleteVPCAssociationAuthorizationError::VPCAssociationAuthorizationNotFound(String::from(parsed_error.message)),_ => {}
}
}
}
DeleteVPCAssociationAuthorizationError::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 DeleteVPCAssociationAuthorizationError {
fn from(err: XmlParseError) -> DeleteVPCAssociationAuthorizationError {
let XmlParseError(message) = err;
DeleteVPCAssociationAuthorizationError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DeleteVPCAssociationAuthorizationError {
fn from(err: CredentialsError) -> DeleteVPCAssociationAuthorizationError {
DeleteVPCAssociationAuthorizationError::Credentials(err)
}
}
impl From<HttpDispatchError> for DeleteVPCAssociationAuthorizationError {
fn from(err: HttpDispatchError) -> DeleteVPCAssociationAuthorizationError {
DeleteVPCAssociationAuthorizationError::HttpDispatch(err)
}
}
impl From<io::Error> for DeleteVPCAssociationAuthorizationError {
fn from(err: io::Error) -> DeleteVPCAssociationAuthorizationError {
DeleteVPCAssociationAuthorizationError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DeleteVPCAssociationAuthorizationError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteVPCAssociationAuthorizationError {
fn description(&self) -> &str {
match *self {
DeleteVPCAssociationAuthorizationError::ConcurrentModification(ref cause) => cause,
DeleteVPCAssociationAuthorizationError::InvalidInput(ref cause) => cause,
DeleteVPCAssociationAuthorizationError::InvalidVPCId(ref cause) => cause,
DeleteVPCAssociationAuthorizationError::NoSuchHostedZone(ref cause) => cause,
DeleteVPCAssociationAuthorizationError::VPCAssociationAuthorizationNotFound(
ref cause,
) => cause,
DeleteVPCAssociationAuthorizationError::Validation(ref cause) => cause,
DeleteVPCAssociationAuthorizationError::Credentials(ref err) => err.description(),
DeleteVPCAssociationAuthorizationError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DeleteVPCAssociationAuthorizationError::ParseError(ref cause) => cause,
DeleteVPCAssociationAuthorizationError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DisassociateVPCFromHostedZoneError {
InvalidInput(String),
InvalidVPCId(String),
LastVPCAssociation(String),
NoSuchHostedZone(String),
VPCAssociationNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DisassociateVPCFromHostedZoneError {
pub fn from_response(res: BufferedHttpResponse) -> DisassociateVPCFromHostedZoneError {
{
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[..] {
"InvalidInput" => {
return DisassociateVPCFromHostedZoneError::InvalidInput(String::from(
parsed_error.message,
));
}
"InvalidVPCId" => {
return DisassociateVPCFromHostedZoneError::InvalidVPCId(String::from(
parsed_error.message,
));
}
"LastVPCAssociation" => {
return DisassociateVPCFromHostedZoneError::LastVPCAssociation(String::from(
parsed_error.message,
));
}
"NoSuchHostedZone" => {
return DisassociateVPCFromHostedZoneError::NoSuchHostedZone(String::from(
parsed_error.message,
));
}
"VPCAssociationNotFound" => {
return DisassociateVPCFromHostedZoneError::VPCAssociationNotFound(
String::from(parsed_error.message),
);
}
_ => {}
}
}
}
DisassociateVPCFromHostedZoneError::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 DisassociateVPCFromHostedZoneError {
fn from(err: XmlParseError) -> DisassociateVPCFromHostedZoneError {
let XmlParseError(message) = err;
DisassociateVPCFromHostedZoneError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DisassociateVPCFromHostedZoneError {
fn from(err: CredentialsError) -> DisassociateVPCFromHostedZoneError {
DisassociateVPCFromHostedZoneError::Credentials(err)
}
}
impl From<HttpDispatchError> for DisassociateVPCFromHostedZoneError {
fn from(err: HttpDispatchError) -> DisassociateVPCFromHostedZoneError {
DisassociateVPCFromHostedZoneError::HttpDispatch(err)
}
}
impl From<io::Error> for DisassociateVPCFromHostedZoneError {
fn from(err: io::Error) -> DisassociateVPCFromHostedZoneError {
DisassociateVPCFromHostedZoneError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DisassociateVPCFromHostedZoneError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DisassociateVPCFromHostedZoneError {
fn description(&self) -> &str {
match *self {
DisassociateVPCFromHostedZoneError::InvalidInput(ref cause) => cause,
DisassociateVPCFromHostedZoneError::InvalidVPCId(ref cause) => cause,
DisassociateVPCFromHostedZoneError::LastVPCAssociation(ref cause) => cause,
DisassociateVPCFromHostedZoneError::NoSuchHostedZone(ref cause) => cause,
DisassociateVPCFromHostedZoneError::VPCAssociationNotFound(ref cause) => cause,
DisassociateVPCFromHostedZoneError::Validation(ref cause) => cause,
DisassociateVPCFromHostedZoneError::Credentials(ref err) => err.description(),
DisassociateVPCFromHostedZoneError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DisassociateVPCFromHostedZoneError::ParseError(ref cause) => cause,
DisassociateVPCFromHostedZoneError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum GetAccountLimitError {
InvalidInput(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl GetAccountLimitError {
pub fn from_response(res: BufferedHttpResponse) -> GetAccountLimitError {
{
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[..] {
"InvalidInput" => {
return GetAccountLimitError::InvalidInput(String::from(
parsed_error.message,
));
}
_ => {}
}
}
}
GetAccountLimitError::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 GetAccountLimitError {
fn from(err: XmlParseError) -> GetAccountLimitError {
let XmlParseError(message) = err;
GetAccountLimitError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for GetAccountLimitError {
fn from(err: CredentialsError) -> GetAccountLimitError {
GetAccountLimitError::Credentials(err)
}
}
impl From<HttpDispatchError> for GetAccountLimitError {
fn from(err: HttpDispatchError) -> GetAccountLimitError {
GetAccountLimitError::HttpDispatch(err)
}
}
impl From<io::Error> for GetAccountLimitError {
fn from(err: io::Error) -> GetAccountLimitError {
GetAccountLimitError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for GetAccountLimitError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetAccountLimitError {
fn description(&self) -> &str {
match *self {
GetAccountLimitError::InvalidInput(ref cause) => cause,
GetAccountLimitError::Validation(ref cause) => cause,
GetAccountLimitError::Credentials(ref err) => err.description(),
GetAccountLimitError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
GetAccountLimitError::ParseError(ref cause) => cause,
GetAccountLimitError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum GetChangeError {
InvalidInput(String),
NoSuchChange(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl GetChangeError {
pub fn from_response(res: BufferedHttpResponse) -> GetChangeError {
{
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[..] {
"InvalidInput" => {
return GetChangeError::InvalidInput(String::from(parsed_error.message));
}
"NoSuchChange" => {
return GetChangeError::NoSuchChange(String::from(parsed_error.message));
}
_ => {}
}
}
}
GetChangeError::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 GetChangeError {
fn from(err: XmlParseError) -> GetChangeError {
let XmlParseError(message) = err;
GetChangeError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for GetChangeError {
fn from(err: CredentialsError) -> GetChangeError {
GetChangeError::Credentials(err)
}
}
impl From<HttpDispatchError> for GetChangeError {
fn from(err: HttpDispatchError) -> GetChangeError {
GetChangeError::HttpDispatch(err)
}
}
impl From<io::Error> for GetChangeError {
fn from(err: io::Error) -> GetChangeError {
GetChangeError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for GetChangeError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetChangeError {
fn description(&self) -> &str {
match *self {
GetChangeError::InvalidInput(ref cause) => cause,
GetChangeError::NoSuchChange(ref cause) => cause,
GetChangeError::Validation(ref cause) => cause,
GetChangeError::Credentials(ref err) => err.description(),
GetChangeError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
GetChangeError::ParseError(ref cause) => cause,
GetChangeError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum GetCheckerIpRangesError {
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl GetCheckerIpRangesError {
pub fn from_response(res: BufferedHttpResponse) -> GetCheckerIpRangesError {
{
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[..] {
_ => {}
}
}
}
GetCheckerIpRangesError::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 GetCheckerIpRangesError {
fn from(err: XmlParseError) -> GetCheckerIpRangesError {
let XmlParseError(message) = err;
GetCheckerIpRangesError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for GetCheckerIpRangesError {
fn from(err: CredentialsError) -> GetCheckerIpRangesError {
GetCheckerIpRangesError::Credentials(err)
}
}
impl From<HttpDispatchError> for GetCheckerIpRangesError {
fn from(err: HttpDispatchError) -> GetCheckerIpRangesError {
GetCheckerIpRangesError::HttpDispatch(err)
}
}
impl From<io::Error> for GetCheckerIpRangesError {
fn from(err: io::Error) -> GetCheckerIpRangesError {
GetCheckerIpRangesError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for GetCheckerIpRangesError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetCheckerIpRangesError {
fn description(&self) -> &str {
match *self {
GetCheckerIpRangesError::Validation(ref cause) => cause,
GetCheckerIpRangesError::Credentials(ref err) => err.description(),
GetCheckerIpRangesError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
GetCheckerIpRangesError::ParseError(ref cause) => cause,
GetCheckerIpRangesError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum GetGeoLocationError {
InvalidInput(String),
NoSuchGeoLocation(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl GetGeoLocationError {
pub fn from_response(res: BufferedHttpResponse) -> GetGeoLocationError {
{
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[..] {
"InvalidInput" => {
return GetGeoLocationError::InvalidInput(String::from(parsed_error.message));
}
"NoSuchGeoLocation" => {
return GetGeoLocationError::NoSuchGeoLocation(String::from(
parsed_error.message,
));
}
_ => {}
}
}
}
GetGeoLocationError::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 GetGeoLocationError {
fn from(err: XmlParseError) -> GetGeoLocationError {
let XmlParseError(message) = err;
GetGeoLocationError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for GetGeoLocationError {
fn from(err: CredentialsError) -> GetGeoLocationError {
GetGeoLocationError::Credentials(err)
}
}
impl From<HttpDispatchError> for GetGeoLocationError {
fn from(err: HttpDispatchError) -> GetGeoLocationError {
GetGeoLocationError::HttpDispatch(err)
}
}
impl From<io::Error> for GetGeoLocationError {
fn from(err: io::Error) -> GetGeoLocationError {
GetGeoLocationError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for GetGeoLocationError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetGeoLocationError {
fn description(&self) -> &str {
match *self {
GetGeoLocationError::InvalidInput(ref cause) => cause,
GetGeoLocationError::NoSuchGeoLocation(ref cause) => cause,
GetGeoLocationError::Validation(ref cause) => cause,
GetGeoLocationError::Credentials(ref err) => err.description(),
GetGeoLocationError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
GetGeoLocationError::ParseError(ref cause) => cause,
GetGeoLocationError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum GetHealthCheckError {
IncompatibleVersion(String),
InvalidInput(String),
NoSuchHealthCheck(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl GetHealthCheckError {
pub fn from_response(res: BufferedHttpResponse) -> GetHealthCheckError {
{
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[..] {
"IncompatibleVersion" => {
return GetHealthCheckError::IncompatibleVersion(String::from(
parsed_error.message,
));
}
"InvalidInput" => {
return GetHealthCheckError::InvalidInput(String::from(parsed_error.message));
}
"NoSuchHealthCheck" => {
return GetHealthCheckError::NoSuchHealthCheck(String::from(
parsed_error.message,
));
}
_ => {}
}
}
}
GetHealthCheckError::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 GetHealthCheckError {
fn from(err: XmlParseError) -> GetHealthCheckError {
let XmlParseError(message) = err;
GetHealthCheckError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for GetHealthCheckError {
fn from(err: CredentialsError) -> GetHealthCheckError {
GetHealthCheckError::Credentials(err)
}
}
impl From<HttpDispatchError> for GetHealthCheckError {
fn from(err: HttpDispatchError) -> GetHealthCheckError {
GetHealthCheckError::HttpDispatch(err)
}
}
impl From<io::Error> for GetHealthCheckError {
fn from(err: io::Error) -> GetHealthCheckError {
GetHealthCheckError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for GetHealthCheckError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetHealthCheckError {
fn description(&self) -> &str {
match *self {
GetHealthCheckError::IncompatibleVersion(ref cause) => cause,
GetHealthCheckError::InvalidInput(ref cause) => cause,
GetHealthCheckError::NoSuchHealthCheck(ref cause) => cause,
GetHealthCheckError::Validation(ref cause) => cause,
GetHealthCheckError::Credentials(ref err) => err.description(),
GetHealthCheckError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
GetHealthCheckError::ParseError(ref cause) => cause,
GetHealthCheckError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum GetHealthCheckCountError {
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl GetHealthCheckCountError {
pub fn from_response(res: BufferedHttpResponse) -> GetHealthCheckCountError {
{
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[..] {
_ => {}
}
}
}
GetHealthCheckCountError::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 GetHealthCheckCountError {
fn from(err: XmlParseError) -> GetHealthCheckCountError {
let XmlParseError(message) = err;
GetHealthCheckCountError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for GetHealthCheckCountError {
fn from(err: CredentialsError) -> GetHealthCheckCountError {
GetHealthCheckCountError::Credentials(err)
}
}
impl From<HttpDispatchError> for GetHealthCheckCountError {
fn from(err: HttpDispatchError) -> GetHealthCheckCountError {
GetHealthCheckCountError::HttpDispatch(err)
}
}
impl From<io::Error> for GetHealthCheckCountError {
fn from(err: io::Error) -> GetHealthCheckCountError {
GetHealthCheckCountError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for GetHealthCheckCountError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetHealthCheckCountError {
fn description(&self) -> &str {
match *self {
GetHealthCheckCountError::Validation(ref cause) => cause,
GetHealthCheckCountError::Credentials(ref err) => err.description(),
GetHealthCheckCountError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
GetHealthCheckCountError::ParseError(ref cause) => cause,
GetHealthCheckCountError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum GetHealthCheckLastFailureReasonError {
InvalidInput(String),
NoSuchHealthCheck(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl GetHealthCheckLastFailureReasonError {
pub fn from_response(res: BufferedHttpResponse) -> GetHealthCheckLastFailureReasonError {
{
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[..] {
"InvalidInput" => {
return GetHealthCheckLastFailureReasonError::InvalidInput(String::from(
parsed_error.message,
));
}
"NoSuchHealthCheck" => {
return GetHealthCheckLastFailureReasonError::NoSuchHealthCheck(
String::from(parsed_error.message),
);
}
_ => {}
}
}
}
GetHealthCheckLastFailureReasonError::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 GetHealthCheckLastFailureReasonError {
fn from(err: XmlParseError) -> GetHealthCheckLastFailureReasonError {
let XmlParseError(message) = err;
GetHealthCheckLastFailureReasonError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for GetHealthCheckLastFailureReasonError {
fn from(err: CredentialsError) -> GetHealthCheckLastFailureReasonError {
GetHealthCheckLastFailureReasonError::Credentials(err)
}
}
impl From<HttpDispatchError> for GetHealthCheckLastFailureReasonError {
fn from(err: HttpDispatchError) -> GetHealthCheckLastFailureReasonError {
GetHealthCheckLastFailureReasonError::HttpDispatch(err)
}
}
impl From<io::Error> for GetHealthCheckLastFailureReasonError {
fn from(err: io::Error) -> GetHealthCheckLastFailureReasonError {
GetHealthCheckLastFailureReasonError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for GetHealthCheckLastFailureReasonError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetHealthCheckLastFailureReasonError {
fn description(&self) -> &str {
match *self {
GetHealthCheckLastFailureReasonError::InvalidInput(ref cause) => cause,
GetHealthCheckLastFailureReasonError::NoSuchHealthCheck(ref cause) => cause,
GetHealthCheckLastFailureReasonError::Validation(ref cause) => cause,
GetHealthCheckLastFailureReasonError::Credentials(ref err) => err.description(),
GetHealthCheckLastFailureReasonError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
GetHealthCheckLastFailureReasonError::ParseError(ref cause) => cause,
GetHealthCheckLastFailureReasonError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum GetHealthCheckStatusError {
InvalidInput(String),
NoSuchHealthCheck(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl GetHealthCheckStatusError {
pub fn from_response(res: BufferedHttpResponse) -> GetHealthCheckStatusError {
{
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[..] {
"InvalidInput" => {
return GetHealthCheckStatusError::InvalidInput(String::from(
parsed_error.message,
));
}
"NoSuchHealthCheck" => {
return GetHealthCheckStatusError::NoSuchHealthCheck(String::from(
parsed_error.message,
));
}
_ => {}
}
}
}
GetHealthCheckStatusError::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 GetHealthCheckStatusError {
fn from(err: XmlParseError) -> GetHealthCheckStatusError {
let XmlParseError(message) = err;
GetHealthCheckStatusError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for GetHealthCheckStatusError {
fn from(err: CredentialsError) -> GetHealthCheckStatusError {
GetHealthCheckStatusError::Credentials(err)
}
}
impl From<HttpDispatchError> for GetHealthCheckStatusError {
fn from(err: HttpDispatchError) -> GetHealthCheckStatusError {
GetHealthCheckStatusError::HttpDispatch(err)
}
}
impl From<io::Error> for GetHealthCheckStatusError {
fn from(err: io::Error) -> GetHealthCheckStatusError {
GetHealthCheckStatusError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for GetHealthCheckStatusError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetHealthCheckStatusError {
fn description(&self) -> &str {
match *self {
GetHealthCheckStatusError::InvalidInput(ref cause) => cause,
GetHealthCheckStatusError::NoSuchHealthCheck(ref cause) => cause,
GetHealthCheckStatusError::Validation(ref cause) => cause,
GetHealthCheckStatusError::Credentials(ref err) => err.description(),
GetHealthCheckStatusError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
GetHealthCheckStatusError::ParseError(ref cause) => cause,
GetHealthCheckStatusError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum GetHostedZoneError {
InvalidInput(String),
NoSuchHostedZone(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl GetHostedZoneError {
pub fn from_response(res: BufferedHttpResponse) -> GetHostedZoneError {
{
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[..] {
"InvalidInput" => {
return GetHostedZoneError::InvalidInput(String::from(parsed_error.message));
}
"NoSuchHostedZone" => {
return GetHostedZoneError::NoSuchHostedZone(String::from(
parsed_error.message,
));
}
_ => {}
}
}
}
GetHostedZoneError::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 GetHostedZoneError {
fn from(err: XmlParseError) -> GetHostedZoneError {
let XmlParseError(message) = err;
GetHostedZoneError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for GetHostedZoneError {
fn from(err: CredentialsError) -> GetHostedZoneError {
GetHostedZoneError::Credentials(err)
}
}
impl From<HttpDispatchError> for GetHostedZoneError {
fn from(err: HttpDispatchError) -> GetHostedZoneError {
GetHostedZoneError::HttpDispatch(err)
}
}
impl From<io::Error> for GetHostedZoneError {
fn from(err: io::Error) -> GetHostedZoneError {
GetHostedZoneError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for GetHostedZoneError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetHostedZoneError {
fn description(&self) -> &str {
match *self {
GetHostedZoneError::InvalidInput(ref cause) => cause,
GetHostedZoneError::NoSuchHostedZone(ref cause) => cause,
GetHostedZoneError::Validation(ref cause) => cause,
GetHostedZoneError::Credentials(ref err) => err.description(),
GetHostedZoneError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
GetHostedZoneError::ParseError(ref cause) => cause,
GetHostedZoneError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum GetHostedZoneCountError {
InvalidInput(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl GetHostedZoneCountError {
pub fn from_response(res: BufferedHttpResponse) -> GetHostedZoneCountError {
{
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[..] {
"InvalidInput" => {
return GetHostedZoneCountError::InvalidInput(String::from(
parsed_error.message,
));
}
_ => {}
}
}
}
GetHostedZoneCountError::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 GetHostedZoneCountError {
fn from(err: XmlParseError) -> GetHostedZoneCountError {
let XmlParseError(message) = err;
GetHostedZoneCountError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for GetHostedZoneCountError {
fn from(err: CredentialsError) -> GetHostedZoneCountError {
GetHostedZoneCountError::Credentials(err)
}
}
impl From<HttpDispatchError> for GetHostedZoneCountError {
fn from(err: HttpDispatchError) -> GetHostedZoneCountError {
GetHostedZoneCountError::HttpDispatch(err)
}
}
impl From<io::Error> for GetHostedZoneCountError {
fn from(err: io::Error) -> GetHostedZoneCountError {
GetHostedZoneCountError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for GetHostedZoneCountError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetHostedZoneCountError {
fn description(&self) -> &str {
match *self {
GetHostedZoneCountError::InvalidInput(ref cause) => cause,
GetHostedZoneCountError::Validation(ref cause) => cause,
GetHostedZoneCountError::Credentials(ref err) => err.description(),
GetHostedZoneCountError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
GetHostedZoneCountError::ParseError(ref cause) => cause,
GetHostedZoneCountError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum GetHostedZoneLimitError {
HostedZoneNotPrivate(String),
InvalidInput(String),
NoSuchHostedZone(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl GetHostedZoneLimitError {
pub fn from_response(res: BufferedHttpResponse) -> GetHostedZoneLimitError {
{
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[..] {
"HostedZoneNotPrivate" => {
return GetHostedZoneLimitError::HostedZoneNotPrivate(String::from(
parsed_error.message,
));
}
"InvalidInput" => {
return GetHostedZoneLimitError::InvalidInput(String::from(
parsed_error.message,
));
}
"NoSuchHostedZone" => {
return GetHostedZoneLimitError::NoSuchHostedZone(String::from(
parsed_error.message,
));
}
_ => {}
}
}
}
GetHostedZoneLimitError::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 GetHostedZoneLimitError {
fn from(err: XmlParseError) -> GetHostedZoneLimitError {
let XmlParseError(message) = err;
GetHostedZoneLimitError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for GetHostedZoneLimitError {
fn from(err: CredentialsError) -> GetHostedZoneLimitError {
GetHostedZoneLimitError::Credentials(err)
}
}
impl From<HttpDispatchError> for GetHostedZoneLimitError {
fn from(err: HttpDispatchError) -> GetHostedZoneLimitError {
GetHostedZoneLimitError::HttpDispatch(err)
}
}
impl From<io::Error> for GetHostedZoneLimitError {
fn from(err: io::Error) -> GetHostedZoneLimitError {
GetHostedZoneLimitError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for GetHostedZoneLimitError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetHostedZoneLimitError {
fn description(&self) -> &str {
match *self {
GetHostedZoneLimitError::HostedZoneNotPrivate(ref cause) => cause,
GetHostedZoneLimitError::InvalidInput(ref cause) => cause,
GetHostedZoneLimitError::NoSuchHostedZone(ref cause) => cause,
GetHostedZoneLimitError::Validation(ref cause) => cause,
GetHostedZoneLimitError::Credentials(ref err) => err.description(),
GetHostedZoneLimitError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
GetHostedZoneLimitError::ParseError(ref cause) => cause,
GetHostedZoneLimitError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum GetQueryLoggingConfigError {
InvalidInput(String),
NoSuchQueryLoggingConfig(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl GetQueryLoggingConfigError {
pub fn from_response(res: BufferedHttpResponse) -> GetQueryLoggingConfigError {
{
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[..] {
"InvalidInput" => {
return GetQueryLoggingConfigError::InvalidInput(String::from(
parsed_error.message,
));
}
"NoSuchQueryLoggingConfig" => {
return GetQueryLoggingConfigError::NoSuchQueryLoggingConfig(String::from(
parsed_error.message,
));
}
_ => {}
}
}
}
GetQueryLoggingConfigError::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 GetQueryLoggingConfigError {
fn from(err: XmlParseError) -> GetQueryLoggingConfigError {
let XmlParseError(message) = err;
GetQueryLoggingConfigError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for GetQueryLoggingConfigError {
fn from(err: CredentialsError) -> GetQueryLoggingConfigError {
GetQueryLoggingConfigError::Credentials(err)
}
}
impl From<HttpDispatchError> for GetQueryLoggingConfigError {
fn from(err: HttpDispatchError) -> GetQueryLoggingConfigError {
GetQueryLoggingConfigError::HttpDispatch(err)
}
}
impl From<io::Error> for GetQueryLoggingConfigError {
fn from(err: io::Error) -> GetQueryLoggingConfigError {
GetQueryLoggingConfigError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for GetQueryLoggingConfigError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetQueryLoggingConfigError {
fn description(&self) -> &str {
match *self {
GetQueryLoggingConfigError::InvalidInput(ref cause) => cause,
GetQueryLoggingConfigError::NoSuchQueryLoggingConfig(ref cause) => cause,
GetQueryLoggingConfigError::Validation(ref cause) => cause,
GetQueryLoggingConfigError::Credentials(ref err) => err.description(),
GetQueryLoggingConfigError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
GetQueryLoggingConfigError::ParseError(ref cause) => cause,
GetQueryLoggingConfigError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum GetReusableDelegationSetError {
DelegationSetNotReusable(String),
InvalidInput(String),
NoSuchDelegationSet(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl GetReusableDelegationSetError {
pub fn from_response(res: BufferedHttpResponse) -> GetReusableDelegationSetError {
{
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[..] {
"DelegationSetNotReusable" => {
return GetReusableDelegationSetError::DelegationSetNotReusable(
String::from(parsed_error.message),
);
}
"InvalidInput" => {
return GetReusableDelegationSetError::InvalidInput(String::from(
parsed_error.message,
));
}
"NoSuchDelegationSet" => {
return GetReusableDelegationSetError::NoSuchDelegationSet(String::from(
parsed_error.message,
));
}
_ => {}
}
}
}
GetReusableDelegationSetError::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 GetReusableDelegationSetError {
fn from(err: XmlParseError) -> GetReusableDelegationSetError {
let XmlParseError(message) = err;
GetReusableDelegationSetError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for GetReusableDelegationSetError {
fn from(err: CredentialsError) -> GetReusableDelegationSetError {
GetReusableDelegationSetError::Credentials(err)
}
}
impl From<HttpDispatchError> for GetReusableDelegationSetError {
fn from(err: HttpDispatchError) -> GetReusableDelegationSetError {
GetReusableDelegationSetError::HttpDispatch(err)
}
}
impl From<io::Error> for GetReusableDelegationSetError {
fn from(err: io::Error) -> GetReusableDelegationSetError {
GetReusableDelegationSetError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for GetReusableDelegationSetError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetReusableDelegationSetError {
fn description(&self) -> &str {
match *self {
GetReusableDelegationSetError::DelegationSetNotReusable(ref cause) => cause,
GetReusableDelegationSetError::InvalidInput(ref cause) => cause,
GetReusableDelegationSetError::NoSuchDelegationSet(ref cause) => cause,
GetReusableDelegationSetError::Validation(ref cause) => cause,
GetReusableDelegationSetError::Credentials(ref err) => err.description(),
GetReusableDelegationSetError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
GetReusableDelegationSetError::ParseError(ref cause) => cause,
GetReusableDelegationSetError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum GetReusableDelegationSetLimitError {
InvalidInput(String),
NoSuchDelegationSet(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl GetReusableDelegationSetLimitError {
pub fn from_response(res: BufferedHttpResponse) -> GetReusableDelegationSetLimitError {
{
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[..] {
"InvalidInput" => {
return GetReusableDelegationSetLimitError::InvalidInput(String::from(
parsed_error.message,
));
}
"NoSuchDelegationSet" => {
return GetReusableDelegationSetLimitError::NoSuchDelegationSet(
String::from(parsed_error.message),
);
}
_ => {}
}
}
}
GetReusableDelegationSetLimitError::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 GetReusableDelegationSetLimitError {
fn from(err: XmlParseError) -> GetReusableDelegationSetLimitError {
let XmlParseError(message) = err;
GetReusableDelegationSetLimitError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for GetReusableDelegationSetLimitError {
fn from(err: CredentialsError) -> GetReusableDelegationSetLimitError {
GetReusableDelegationSetLimitError::Credentials(err)
}
}
impl From<HttpDispatchError> for GetReusableDelegationSetLimitError {
fn from(err: HttpDispatchError) -> GetReusableDelegationSetLimitError {
GetReusableDelegationSetLimitError::HttpDispatch(err)
}
}
impl From<io::Error> for GetReusableDelegationSetLimitError {
fn from(err: io::Error) -> GetReusableDelegationSetLimitError {
GetReusableDelegationSetLimitError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for GetReusableDelegationSetLimitError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetReusableDelegationSetLimitError {
fn description(&self) -> &str {
match *self {
GetReusableDelegationSetLimitError::InvalidInput(ref cause) => cause,
GetReusableDelegationSetLimitError::NoSuchDelegationSet(ref cause) => cause,
GetReusableDelegationSetLimitError::Validation(ref cause) => cause,
GetReusableDelegationSetLimitError::Credentials(ref err) => err.description(),
GetReusableDelegationSetLimitError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
GetReusableDelegationSetLimitError::ParseError(ref cause) => cause,
GetReusableDelegationSetLimitError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum GetTrafficPolicyError {
InvalidInput(String),
NoSuchTrafficPolicy(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl GetTrafficPolicyError {
pub fn from_response(res: BufferedHttpResponse) -> GetTrafficPolicyError {
{
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[..] {
"InvalidInput" => {
return GetTrafficPolicyError::InvalidInput(String::from(
parsed_error.message,
));
}
"NoSuchTrafficPolicy" => {
return GetTrafficPolicyError::NoSuchTrafficPolicy(String::from(
parsed_error.message,
));
}
_ => {}
}
}
}
GetTrafficPolicyError::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 GetTrafficPolicyError {
fn from(err: XmlParseError) -> GetTrafficPolicyError {
let XmlParseError(message) = err;
GetTrafficPolicyError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for GetTrafficPolicyError {
fn from(err: CredentialsError) -> GetTrafficPolicyError {
GetTrafficPolicyError::Credentials(err)
}
}
impl From<HttpDispatchError> for GetTrafficPolicyError {
fn from(err: HttpDispatchError) -> GetTrafficPolicyError {
GetTrafficPolicyError::HttpDispatch(err)
}
}
impl From<io::Error> for GetTrafficPolicyError {
fn from(err: io::Error) -> GetTrafficPolicyError {
GetTrafficPolicyError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for GetTrafficPolicyError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetTrafficPolicyError {
fn description(&self) -> &str {
match *self {
GetTrafficPolicyError::InvalidInput(ref cause) => cause,
GetTrafficPolicyError::NoSuchTrafficPolicy(ref cause) => cause,
GetTrafficPolicyError::Validation(ref cause) => cause,
GetTrafficPolicyError::Credentials(ref err) => err.description(),
GetTrafficPolicyError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
GetTrafficPolicyError::ParseError(ref cause) => cause,
GetTrafficPolicyError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum GetTrafficPolicyInstanceError {
InvalidInput(String),
NoSuchTrafficPolicyInstance(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl GetTrafficPolicyInstanceError {
pub fn from_response(res: BufferedHttpResponse) -> GetTrafficPolicyInstanceError {
{
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[..] {
"InvalidInput" => {
return GetTrafficPolicyInstanceError::InvalidInput(String::from(
parsed_error.message,
));
}
"NoSuchTrafficPolicyInstance" => {
return GetTrafficPolicyInstanceError::NoSuchTrafficPolicyInstance(
String::from(parsed_error.message),
);
}
_ => {}
}
}
}
GetTrafficPolicyInstanceError::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 GetTrafficPolicyInstanceError {
fn from(err: XmlParseError) -> GetTrafficPolicyInstanceError {
let XmlParseError(message) = err;
GetTrafficPolicyInstanceError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for GetTrafficPolicyInstanceError {
fn from(err: CredentialsError) -> GetTrafficPolicyInstanceError {
GetTrafficPolicyInstanceError::Credentials(err)
}
}
impl From<HttpDispatchError> for GetTrafficPolicyInstanceError {
fn from(err: HttpDispatchError) -> GetTrafficPolicyInstanceError {
GetTrafficPolicyInstanceError::HttpDispatch(err)
}
}
impl From<io::Error> for GetTrafficPolicyInstanceError {
fn from(err: io::Error) -> GetTrafficPolicyInstanceError {
GetTrafficPolicyInstanceError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for GetTrafficPolicyInstanceError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetTrafficPolicyInstanceError {
fn description(&self) -> &str {
match *self {
GetTrafficPolicyInstanceError::InvalidInput(ref cause) => cause,
GetTrafficPolicyInstanceError::NoSuchTrafficPolicyInstance(ref cause) => cause,
GetTrafficPolicyInstanceError::Validation(ref cause) => cause,
GetTrafficPolicyInstanceError::Credentials(ref err) => err.description(),
GetTrafficPolicyInstanceError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
GetTrafficPolicyInstanceError::ParseError(ref cause) => cause,
GetTrafficPolicyInstanceError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum GetTrafficPolicyInstanceCountError {
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl GetTrafficPolicyInstanceCountError {
pub fn from_response(res: BufferedHttpResponse) -> GetTrafficPolicyInstanceCountError {
{
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[..] {
_ => {}
}
}
}
GetTrafficPolicyInstanceCountError::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 GetTrafficPolicyInstanceCountError {
fn from(err: XmlParseError) -> GetTrafficPolicyInstanceCountError {
let XmlParseError(message) = err;
GetTrafficPolicyInstanceCountError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for GetTrafficPolicyInstanceCountError {
fn from(err: CredentialsError) -> GetTrafficPolicyInstanceCountError {
GetTrafficPolicyInstanceCountError::Credentials(err)
}
}
impl From<HttpDispatchError> for GetTrafficPolicyInstanceCountError {
fn from(err: HttpDispatchError) -> GetTrafficPolicyInstanceCountError {
GetTrafficPolicyInstanceCountError::HttpDispatch(err)
}
}
impl From<io::Error> for GetTrafficPolicyInstanceCountError {
fn from(err: io::Error) -> GetTrafficPolicyInstanceCountError {
GetTrafficPolicyInstanceCountError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for GetTrafficPolicyInstanceCountError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetTrafficPolicyInstanceCountError {
fn description(&self) -> &str {
match *self {
GetTrafficPolicyInstanceCountError::Validation(ref cause) => cause,
GetTrafficPolicyInstanceCountError::Credentials(ref err) => err.description(),
GetTrafficPolicyInstanceCountError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
GetTrafficPolicyInstanceCountError::ParseError(ref cause) => cause,
GetTrafficPolicyInstanceCountError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ListGeoLocationsError {
InvalidInput(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ListGeoLocationsError {
pub fn from_response(res: BufferedHttpResponse) -> ListGeoLocationsError {
{
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[..] {
"InvalidInput" => {
return ListGeoLocationsError::InvalidInput(String::from(
parsed_error.message,
));
}
_ => {}
}
}
}
ListGeoLocationsError::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 ListGeoLocationsError {
fn from(err: XmlParseError) -> ListGeoLocationsError {
let XmlParseError(message) = err;
ListGeoLocationsError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for ListGeoLocationsError {
fn from(err: CredentialsError) -> ListGeoLocationsError {
ListGeoLocationsError::Credentials(err)
}
}
impl From<HttpDispatchError> for ListGeoLocationsError {
fn from(err: HttpDispatchError) -> ListGeoLocationsError {
ListGeoLocationsError::HttpDispatch(err)
}
}
impl From<io::Error> for ListGeoLocationsError {
fn from(err: io::Error) -> ListGeoLocationsError {
ListGeoLocationsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ListGeoLocationsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ListGeoLocationsError {
fn description(&self) -> &str {
match *self {
ListGeoLocationsError::InvalidInput(ref cause) => cause,
ListGeoLocationsError::Validation(ref cause) => cause,
ListGeoLocationsError::Credentials(ref err) => err.description(),
ListGeoLocationsError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
ListGeoLocationsError::ParseError(ref cause) => cause,
ListGeoLocationsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ListHealthChecksError {
IncompatibleVersion(String),
InvalidInput(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ListHealthChecksError {
pub fn from_response(res: BufferedHttpResponse) -> ListHealthChecksError {
{
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[..] {
"IncompatibleVersion" => {
return ListHealthChecksError::IncompatibleVersion(String::from(
parsed_error.message,
));
}
"InvalidInput" => {
return ListHealthChecksError::InvalidInput(String::from(
parsed_error.message,
));
}
_ => {}
}
}
}
ListHealthChecksError::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 ListHealthChecksError {
fn from(err: XmlParseError) -> ListHealthChecksError {
let XmlParseError(message) = err;
ListHealthChecksError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for ListHealthChecksError {
fn from(err: CredentialsError) -> ListHealthChecksError {
ListHealthChecksError::Credentials(err)
}
}
impl From<HttpDispatchError> for ListHealthChecksError {
fn from(err: HttpDispatchError) -> ListHealthChecksError {
ListHealthChecksError::HttpDispatch(err)
}
}
impl From<io::Error> for ListHealthChecksError {
fn from(err: io::Error) -> ListHealthChecksError {
ListHealthChecksError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ListHealthChecksError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ListHealthChecksError {
fn description(&self) -> &str {
match *self {
ListHealthChecksError::IncompatibleVersion(ref cause) => cause,
ListHealthChecksError::InvalidInput(ref cause) => cause,
ListHealthChecksError::Validation(ref cause) => cause,
ListHealthChecksError::Credentials(ref err) => err.description(),
ListHealthChecksError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
ListHealthChecksError::ParseError(ref cause) => cause,
ListHealthChecksError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ListHostedZonesError {
DelegationSetNotReusable(String),
InvalidInput(String),
NoSuchDelegationSet(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ListHostedZonesError {
pub fn from_response(res: BufferedHttpResponse) -> ListHostedZonesError {
{
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[..] {
"DelegationSetNotReusable" => {
return ListHostedZonesError::DelegationSetNotReusable(String::from(
parsed_error.message,
));
}
"InvalidInput" => {
return ListHostedZonesError::InvalidInput(String::from(
parsed_error.message,
));
}
"NoSuchDelegationSet" => {
return ListHostedZonesError::NoSuchDelegationSet(String::from(
parsed_error.message,
));
}
_ => {}
}
}
}
ListHostedZonesError::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 ListHostedZonesError {
fn from(err: XmlParseError) -> ListHostedZonesError {
let XmlParseError(message) = err;
ListHostedZonesError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for ListHostedZonesError {
fn from(err: CredentialsError) -> ListHostedZonesError {
ListHostedZonesError::Credentials(err)
}
}
impl From<HttpDispatchError> for ListHostedZonesError {
fn from(err: HttpDispatchError) -> ListHostedZonesError {
ListHostedZonesError::HttpDispatch(err)
}
}
impl From<io::Error> for ListHostedZonesError {
fn from(err: io::Error) -> ListHostedZonesError {
ListHostedZonesError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ListHostedZonesError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ListHostedZonesError {
fn description(&self) -> &str {
match *self {
ListHostedZonesError::DelegationSetNotReusable(ref cause) => cause,
ListHostedZonesError::InvalidInput(ref cause) => cause,
ListHostedZonesError::NoSuchDelegationSet(ref cause) => cause,
ListHostedZonesError::Validation(ref cause) => cause,
ListHostedZonesError::Credentials(ref err) => err.description(),
ListHostedZonesError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
ListHostedZonesError::ParseError(ref cause) => cause,
ListHostedZonesError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ListHostedZonesByNameError {
InvalidDomainName(String),
InvalidInput(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ListHostedZonesByNameError {
pub fn from_response(res: BufferedHttpResponse) -> ListHostedZonesByNameError {
{
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[..] {
"InvalidDomainName" => {
return ListHostedZonesByNameError::InvalidDomainName(String::from(
parsed_error.message,
));
}
"InvalidInput" => {
return ListHostedZonesByNameError::InvalidInput(String::from(
parsed_error.message,
));
}
_ => {}
}
}
}
ListHostedZonesByNameError::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 ListHostedZonesByNameError {
fn from(err: XmlParseError) -> ListHostedZonesByNameError {
let XmlParseError(message) = err;
ListHostedZonesByNameError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for ListHostedZonesByNameError {
fn from(err: CredentialsError) -> ListHostedZonesByNameError {
ListHostedZonesByNameError::Credentials(err)
}
}
impl From<HttpDispatchError> for ListHostedZonesByNameError {
fn from(err: HttpDispatchError) -> ListHostedZonesByNameError {
ListHostedZonesByNameError::HttpDispatch(err)
}
}
impl From<io::Error> for ListHostedZonesByNameError {
fn from(err: io::Error) -> ListHostedZonesByNameError {
ListHostedZonesByNameError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ListHostedZonesByNameError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ListHostedZonesByNameError {
fn description(&self) -> &str {
match *self {
ListHostedZonesByNameError::InvalidDomainName(ref cause) => cause,
ListHostedZonesByNameError::InvalidInput(ref cause) => cause,
ListHostedZonesByNameError::Validation(ref cause) => cause,
ListHostedZonesByNameError::Credentials(ref err) => err.description(),
ListHostedZonesByNameError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
ListHostedZonesByNameError::ParseError(ref cause) => cause,
ListHostedZonesByNameError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ListQueryLoggingConfigsError {
InvalidInput(String),
InvalidPaginationToken(String),
NoSuchHostedZone(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ListQueryLoggingConfigsError {
pub fn from_response(res: BufferedHttpResponse) -> ListQueryLoggingConfigsError {
{
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[..] {
"InvalidInput" => {
return ListQueryLoggingConfigsError::InvalidInput(String::from(
parsed_error.message,
));
}
"InvalidPaginationToken" => {
return ListQueryLoggingConfigsError::InvalidPaginationToken(String::from(
parsed_error.message,
));
}
"NoSuchHostedZone" => {
return ListQueryLoggingConfigsError::NoSuchHostedZone(String::from(
parsed_error.message,
));
}
_ => {}
}
}
}
ListQueryLoggingConfigsError::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 ListQueryLoggingConfigsError {
fn from(err: XmlParseError) -> ListQueryLoggingConfigsError {
let XmlParseError(message) = err;
ListQueryLoggingConfigsError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for ListQueryLoggingConfigsError {
fn from(err: CredentialsError) -> ListQueryLoggingConfigsError {
ListQueryLoggingConfigsError::Credentials(err)
}
}
impl From<HttpDispatchError> for ListQueryLoggingConfigsError {
fn from(err: HttpDispatchError) -> ListQueryLoggingConfigsError {
ListQueryLoggingConfigsError::HttpDispatch(err)
}
}
impl From<io::Error> for ListQueryLoggingConfigsError {
fn from(err: io::Error) -> ListQueryLoggingConfigsError {
ListQueryLoggingConfigsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ListQueryLoggingConfigsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ListQueryLoggingConfigsError {
fn description(&self) -> &str {
match *self {
ListQueryLoggingConfigsError::InvalidInput(ref cause) => cause,
ListQueryLoggingConfigsError::InvalidPaginationToken(ref cause) => cause,
ListQueryLoggingConfigsError::NoSuchHostedZone(ref cause) => cause,
ListQueryLoggingConfigsError::Validation(ref cause) => cause,
ListQueryLoggingConfigsError::Credentials(ref err) => err.description(),
ListQueryLoggingConfigsError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
ListQueryLoggingConfigsError::ParseError(ref cause) => cause,
ListQueryLoggingConfigsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ListResourceRecordSetsError {
InvalidInput(String),
NoSuchHostedZone(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ListResourceRecordSetsError {
pub fn from_response(res: BufferedHttpResponse) -> ListResourceRecordSetsError {
{
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[..] {
"InvalidInput" => {
return ListResourceRecordSetsError::InvalidInput(String::from(
parsed_error.message,
));
}
"NoSuchHostedZone" => {
return ListResourceRecordSetsError::NoSuchHostedZone(String::from(
parsed_error.message,
));
}
_ => {}
}
}
}
ListResourceRecordSetsError::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 ListResourceRecordSetsError {
fn from(err: XmlParseError) -> ListResourceRecordSetsError {
let XmlParseError(message) = err;
ListResourceRecordSetsError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for ListResourceRecordSetsError {
fn from(err: CredentialsError) -> ListResourceRecordSetsError {
ListResourceRecordSetsError::Credentials(err)
}
}
impl From<HttpDispatchError> for ListResourceRecordSetsError {
fn from(err: HttpDispatchError) -> ListResourceRecordSetsError {
ListResourceRecordSetsError::HttpDispatch(err)
}
}
impl From<io::Error> for ListResourceRecordSetsError {
fn from(err: io::Error) -> ListResourceRecordSetsError {
ListResourceRecordSetsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ListResourceRecordSetsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ListResourceRecordSetsError {
fn description(&self) -> &str {
match *self {
ListResourceRecordSetsError::InvalidInput(ref cause) => cause,
ListResourceRecordSetsError::NoSuchHostedZone(ref cause) => cause,
ListResourceRecordSetsError::Validation(ref cause) => cause,
ListResourceRecordSetsError::Credentials(ref err) => err.description(),
ListResourceRecordSetsError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
ListResourceRecordSetsError::ParseError(ref cause) => cause,
ListResourceRecordSetsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ListReusableDelegationSetsError {
InvalidInput(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ListReusableDelegationSetsError {
pub fn from_response(res: BufferedHttpResponse) -> ListReusableDelegationSetsError {
{
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[..] {
"InvalidInput" => {
return ListReusableDelegationSetsError::InvalidInput(String::from(
parsed_error.message,
));
}
_ => {}
}
}
}
ListReusableDelegationSetsError::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 ListReusableDelegationSetsError {
fn from(err: XmlParseError) -> ListReusableDelegationSetsError {
let XmlParseError(message) = err;
ListReusableDelegationSetsError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for ListReusableDelegationSetsError {
fn from(err: CredentialsError) -> ListReusableDelegationSetsError {
ListReusableDelegationSetsError::Credentials(err)
}
}
impl From<HttpDispatchError> for ListReusableDelegationSetsError {
fn from(err: HttpDispatchError) -> ListReusableDelegationSetsError {
ListReusableDelegationSetsError::HttpDispatch(err)
}
}
impl From<io::Error> for ListReusableDelegationSetsError {
fn from(err: io::Error) -> ListReusableDelegationSetsError {
ListReusableDelegationSetsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ListReusableDelegationSetsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ListReusableDelegationSetsError {
fn description(&self) -> &str {
match *self {
ListReusableDelegationSetsError::InvalidInput(ref cause) => cause,
ListReusableDelegationSetsError::Validation(ref cause) => cause,
ListReusableDelegationSetsError::Credentials(ref err) => err.description(),
ListReusableDelegationSetsError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
ListReusableDelegationSetsError::ParseError(ref cause) => cause,
ListReusableDelegationSetsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ListTagsForResourceError {
InvalidInput(String),
NoSuchHealthCheck(String),
NoSuchHostedZone(String),
PriorRequestNotComplete(String),
Throttling(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ListTagsForResourceError {
pub fn from_response(res: BufferedHttpResponse) -> ListTagsForResourceError {
{
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[..] {
"InvalidInput" => {
return ListTagsForResourceError::InvalidInput(String::from(
parsed_error.message,
));
}
"NoSuchHealthCheck" => {
return ListTagsForResourceError::NoSuchHealthCheck(String::from(
parsed_error.message,
));
}
"NoSuchHostedZone" => {
return ListTagsForResourceError::NoSuchHostedZone(String::from(
parsed_error.message,
));
}
"PriorRequestNotComplete" => {
return ListTagsForResourceError::PriorRequestNotComplete(String::from(
parsed_error.message,
));
}
"ThrottlingException" => {
return ListTagsForResourceError::Throttling(String::from(
parsed_error.message,
));
}
_ => {}
}
}
}
ListTagsForResourceError::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 ListTagsForResourceError {
fn from(err: XmlParseError) -> ListTagsForResourceError {
let XmlParseError(message) = err;
ListTagsForResourceError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for ListTagsForResourceError {
fn from(err: CredentialsError) -> ListTagsForResourceError {
ListTagsForResourceError::Credentials(err)
}
}
impl From<HttpDispatchError> for ListTagsForResourceError {
fn from(err: HttpDispatchError) -> ListTagsForResourceError {
ListTagsForResourceError::HttpDispatch(err)
}
}
impl From<io::Error> for ListTagsForResourceError {
fn from(err: io::Error) -> ListTagsForResourceError {
ListTagsForResourceError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ListTagsForResourceError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ListTagsForResourceError {
fn description(&self) -> &str {
match *self {
ListTagsForResourceError::InvalidInput(ref cause) => cause,
ListTagsForResourceError::NoSuchHealthCheck(ref cause) => cause,
ListTagsForResourceError::NoSuchHostedZone(ref cause) => cause,
ListTagsForResourceError::PriorRequestNotComplete(ref cause) => cause,
ListTagsForResourceError::Throttling(ref cause) => cause,
ListTagsForResourceError::Validation(ref cause) => cause,
ListTagsForResourceError::Credentials(ref err) => err.description(),
ListTagsForResourceError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
ListTagsForResourceError::ParseError(ref cause) => cause,
ListTagsForResourceError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ListTagsForResourcesError {
InvalidInput(String),
NoSuchHealthCheck(String),
NoSuchHostedZone(String),
PriorRequestNotComplete(String),
Throttling(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ListTagsForResourcesError {
pub fn from_response(res: BufferedHttpResponse) -> ListTagsForResourcesError {
{
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[..] {
"InvalidInput" => {
return ListTagsForResourcesError::InvalidInput(String::from(
parsed_error.message,
));
}
"NoSuchHealthCheck" => {
return ListTagsForResourcesError::NoSuchHealthCheck(String::from(
parsed_error.message,
));
}
"NoSuchHostedZone" => {
return ListTagsForResourcesError::NoSuchHostedZone(String::from(
parsed_error.message,
));
}
"PriorRequestNotComplete" => {
return ListTagsForResourcesError::PriorRequestNotComplete(String::from(
parsed_error.message,
));
}
"ThrottlingException" => {
return ListTagsForResourcesError::Throttling(String::from(
parsed_error.message,
));
}
_ => {}
}
}
}
ListTagsForResourcesError::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 ListTagsForResourcesError {
fn from(err: XmlParseError) -> ListTagsForResourcesError {
let XmlParseError(message) = err;
ListTagsForResourcesError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for ListTagsForResourcesError {
fn from(err: CredentialsError) -> ListTagsForResourcesError {
ListTagsForResourcesError::Credentials(err)
}
}
impl From<HttpDispatchError> for ListTagsForResourcesError {
fn from(err: HttpDispatchError) -> ListTagsForResourcesError {
ListTagsForResourcesError::HttpDispatch(err)
}
}
impl From<io::Error> for ListTagsForResourcesError {
fn from(err: io::Error) -> ListTagsForResourcesError {
ListTagsForResourcesError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ListTagsForResourcesError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ListTagsForResourcesError {
fn description(&self) -> &str {
match *self {
ListTagsForResourcesError::InvalidInput(ref cause) => cause,
ListTagsForResourcesError::NoSuchHealthCheck(ref cause) => cause,
ListTagsForResourcesError::NoSuchHostedZone(ref cause) => cause,
ListTagsForResourcesError::PriorRequestNotComplete(ref cause) => cause,
ListTagsForResourcesError::Throttling(ref cause) => cause,
ListTagsForResourcesError::Validation(ref cause) => cause,
ListTagsForResourcesError::Credentials(ref err) => err.description(),
ListTagsForResourcesError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
ListTagsForResourcesError::ParseError(ref cause) => cause,
ListTagsForResourcesError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ListTrafficPoliciesError {
InvalidInput(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ListTrafficPoliciesError {
pub fn from_response(res: BufferedHttpResponse) -> ListTrafficPoliciesError {
{
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[..] {
"InvalidInput" => {
return ListTrafficPoliciesError::InvalidInput(String::from(
parsed_error.message,
));
}
_ => {}
}
}
}
ListTrafficPoliciesError::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 ListTrafficPoliciesError {
fn from(err: XmlParseError) -> ListTrafficPoliciesError {
let XmlParseError(message) = err;
ListTrafficPoliciesError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for ListTrafficPoliciesError {
fn from(err: CredentialsError) -> ListTrafficPoliciesError {
ListTrafficPoliciesError::Credentials(err)
}
}
impl From<HttpDispatchError> for ListTrafficPoliciesError {
fn from(err: HttpDispatchError) -> ListTrafficPoliciesError {
ListTrafficPoliciesError::HttpDispatch(err)
}
}
impl From<io::Error> for ListTrafficPoliciesError {
fn from(err: io::Error) -> ListTrafficPoliciesError {
ListTrafficPoliciesError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ListTrafficPoliciesError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ListTrafficPoliciesError {
fn description(&self) -> &str {
match *self {
ListTrafficPoliciesError::InvalidInput(ref cause) => cause,
ListTrafficPoliciesError::Validation(ref cause) => cause,
ListTrafficPoliciesError::Credentials(ref err) => err.description(),
ListTrafficPoliciesError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
ListTrafficPoliciesError::ParseError(ref cause) => cause,
ListTrafficPoliciesError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ListTrafficPolicyInstancesError {
InvalidInput(String),
NoSuchTrafficPolicyInstance(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ListTrafficPolicyInstancesError {
pub fn from_response(res: BufferedHttpResponse) -> ListTrafficPolicyInstancesError {
{
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[..] {
"InvalidInput" => {
return ListTrafficPolicyInstancesError::InvalidInput(String::from(
parsed_error.message,
));
}
"NoSuchTrafficPolicyInstance" => {
return ListTrafficPolicyInstancesError::NoSuchTrafficPolicyInstance(
String::from(parsed_error.message),
);
}
_ => {}
}
}
}
ListTrafficPolicyInstancesError::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 ListTrafficPolicyInstancesError {
fn from(err: XmlParseError) -> ListTrafficPolicyInstancesError {
let XmlParseError(message) = err;
ListTrafficPolicyInstancesError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for ListTrafficPolicyInstancesError {
fn from(err: CredentialsError) -> ListTrafficPolicyInstancesError {
ListTrafficPolicyInstancesError::Credentials(err)
}
}
impl From<HttpDispatchError> for ListTrafficPolicyInstancesError {
fn from(err: HttpDispatchError) -> ListTrafficPolicyInstancesError {
ListTrafficPolicyInstancesError::HttpDispatch(err)
}
}
impl From<io::Error> for ListTrafficPolicyInstancesError {
fn from(err: io::Error) -> ListTrafficPolicyInstancesError {
ListTrafficPolicyInstancesError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ListTrafficPolicyInstancesError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ListTrafficPolicyInstancesError {
fn description(&self) -> &str {
match *self {
ListTrafficPolicyInstancesError::InvalidInput(ref cause) => cause,
ListTrafficPolicyInstancesError::NoSuchTrafficPolicyInstance(ref cause) => cause,
ListTrafficPolicyInstancesError::Validation(ref cause) => cause,
ListTrafficPolicyInstancesError::Credentials(ref err) => err.description(),
ListTrafficPolicyInstancesError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
ListTrafficPolicyInstancesError::ParseError(ref cause) => cause,
ListTrafficPolicyInstancesError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ListTrafficPolicyInstancesByHostedZoneError {
InvalidInput(String),
NoSuchHostedZone(String),
NoSuchTrafficPolicyInstance(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ListTrafficPolicyInstancesByHostedZoneError {
pub fn from_response(res: BufferedHttpResponse) -> ListTrafficPolicyInstancesByHostedZoneError {
{
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[..] {
"InvalidInput" => return ListTrafficPolicyInstancesByHostedZoneError::InvalidInput(String::from(parsed_error.message)),"NoSuchHostedZone" => return ListTrafficPolicyInstancesByHostedZoneError::NoSuchHostedZone(String::from(parsed_error.message)),"NoSuchTrafficPolicyInstance" => return ListTrafficPolicyInstancesByHostedZoneError::NoSuchTrafficPolicyInstance(String::from(parsed_error.message)),_ => {}
}
}
}
ListTrafficPolicyInstancesByHostedZoneError::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 ListTrafficPolicyInstancesByHostedZoneError {
fn from(err: XmlParseError) -> ListTrafficPolicyInstancesByHostedZoneError {
let XmlParseError(message) = err;
ListTrafficPolicyInstancesByHostedZoneError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for ListTrafficPolicyInstancesByHostedZoneError {
fn from(err: CredentialsError) -> ListTrafficPolicyInstancesByHostedZoneError {
ListTrafficPolicyInstancesByHostedZoneError::Credentials(err)
}
}
impl From<HttpDispatchError> for ListTrafficPolicyInstancesByHostedZoneError {
fn from(err: HttpDispatchError) -> ListTrafficPolicyInstancesByHostedZoneError {
ListTrafficPolicyInstancesByHostedZoneError::HttpDispatch(err)
}
}
impl From<io::Error> for ListTrafficPolicyInstancesByHostedZoneError {
fn from(err: io::Error) -> ListTrafficPolicyInstancesByHostedZoneError {
ListTrafficPolicyInstancesByHostedZoneError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ListTrafficPolicyInstancesByHostedZoneError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ListTrafficPolicyInstancesByHostedZoneError {
fn description(&self) -> &str {
match *self {
ListTrafficPolicyInstancesByHostedZoneError::InvalidInput(ref cause) => cause,
ListTrafficPolicyInstancesByHostedZoneError::NoSuchHostedZone(ref cause) => cause,
ListTrafficPolicyInstancesByHostedZoneError::NoSuchTrafficPolicyInstance(ref cause) => {
cause
}
ListTrafficPolicyInstancesByHostedZoneError::Validation(ref cause) => cause,
ListTrafficPolicyInstancesByHostedZoneError::Credentials(ref err) => err.description(),
ListTrafficPolicyInstancesByHostedZoneError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
ListTrafficPolicyInstancesByHostedZoneError::ParseError(ref cause) => cause,
ListTrafficPolicyInstancesByHostedZoneError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ListTrafficPolicyInstancesByPolicyError {
InvalidInput(String),
NoSuchTrafficPolicy(String),
NoSuchTrafficPolicyInstance(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ListTrafficPolicyInstancesByPolicyError {
pub fn from_response(res: BufferedHttpResponse) -> ListTrafficPolicyInstancesByPolicyError {
{
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[..] {
"InvalidInput" => {
return ListTrafficPolicyInstancesByPolicyError::InvalidInput(String::from(
parsed_error.message,
));
}
"NoSuchTrafficPolicy" => {
return ListTrafficPolicyInstancesByPolicyError::NoSuchTrafficPolicy(
String::from(parsed_error.message),
);
}
"NoSuchTrafficPolicyInstance" => {
return ListTrafficPolicyInstancesByPolicyError::NoSuchTrafficPolicyInstance(
String::from(parsed_error.message),
);
}
_ => {}
}
}
}
ListTrafficPolicyInstancesByPolicyError::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 ListTrafficPolicyInstancesByPolicyError {
fn from(err: XmlParseError) -> ListTrafficPolicyInstancesByPolicyError {
let XmlParseError(message) = err;
ListTrafficPolicyInstancesByPolicyError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for ListTrafficPolicyInstancesByPolicyError {
fn from(err: CredentialsError) -> ListTrafficPolicyInstancesByPolicyError {
ListTrafficPolicyInstancesByPolicyError::Credentials(err)
}
}
impl From<HttpDispatchError> for ListTrafficPolicyInstancesByPolicyError {
fn from(err: HttpDispatchError) -> ListTrafficPolicyInstancesByPolicyError {
ListTrafficPolicyInstancesByPolicyError::HttpDispatch(err)
}
}
impl From<io::Error> for ListTrafficPolicyInstancesByPolicyError {
fn from(err: io::Error) -> ListTrafficPolicyInstancesByPolicyError {
ListTrafficPolicyInstancesByPolicyError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ListTrafficPolicyInstancesByPolicyError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ListTrafficPolicyInstancesByPolicyError {
fn description(&self) -> &str {
match *self {
ListTrafficPolicyInstancesByPolicyError::InvalidInput(ref cause) => cause,
ListTrafficPolicyInstancesByPolicyError::NoSuchTrafficPolicy(ref cause) => cause,
ListTrafficPolicyInstancesByPolicyError::NoSuchTrafficPolicyInstance(ref cause) => {
cause
}
ListTrafficPolicyInstancesByPolicyError::Validation(ref cause) => cause,
ListTrafficPolicyInstancesByPolicyError::Credentials(ref err) => err.description(),
ListTrafficPolicyInstancesByPolicyError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
ListTrafficPolicyInstancesByPolicyError::ParseError(ref cause) => cause,
ListTrafficPolicyInstancesByPolicyError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ListTrafficPolicyVersionsError {
InvalidInput(String),
NoSuchTrafficPolicy(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ListTrafficPolicyVersionsError {
pub fn from_response(res: BufferedHttpResponse) -> ListTrafficPolicyVersionsError {
{
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[..] {
"InvalidInput" => {
return ListTrafficPolicyVersionsError::InvalidInput(String::from(
parsed_error.message,
));
}
"NoSuchTrafficPolicy" => {
return ListTrafficPolicyVersionsError::NoSuchTrafficPolicy(String::from(
parsed_error.message,
));
}
_ => {}
}
}
}
ListTrafficPolicyVersionsError::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 ListTrafficPolicyVersionsError {
fn from(err: XmlParseError) -> ListTrafficPolicyVersionsError {
let XmlParseError(message) = err;
ListTrafficPolicyVersionsError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for ListTrafficPolicyVersionsError {
fn from(err: CredentialsError) -> ListTrafficPolicyVersionsError {
ListTrafficPolicyVersionsError::Credentials(err)
}
}
impl From<HttpDispatchError> for ListTrafficPolicyVersionsError {
fn from(err: HttpDispatchError) -> ListTrafficPolicyVersionsError {
ListTrafficPolicyVersionsError::HttpDispatch(err)
}
}
impl From<io::Error> for ListTrafficPolicyVersionsError {
fn from(err: io::Error) -> ListTrafficPolicyVersionsError {
ListTrafficPolicyVersionsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ListTrafficPolicyVersionsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ListTrafficPolicyVersionsError {
fn description(&self) -> &str {
match *self {
ListTrafficPolicyVersionsError::InvalidInput(ref cause) => cause,
ListTrafficPolicyVersionsError::NoSuchTrafficPolicy(ref cause) => cause,
ListTrafficPolicyVersionsError::Validation(ref cause) => cause,
ListTrafficPolicyVersionsError::Credentials(ref err) => err.description(),
ListTrafficPolicyVersionsError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
ListTrafficPolicyVersionsError::ParseError(ref cause) => cause,
ListTrafficPolicyVersionsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ListVPCAssociationAuthorizationsError {
InvalidInput(String),
InvalidPaginationToken(String),
NoSuchHostedZone(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ListVPCAssociationAuthorizationsError {
pub fn from_response(res: BufferedHttpResponse) -> ListVPCAssociationAuthorizationsError {
{
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[..] {
"InvalidInput" => {
return ListVPCAssociationAuthorizationsError::InvalidInput(String::from(
parsed_error.message,
));
}
"InvalidPaginationToken" => {
return ListVPCAssociationAuthorizationsError::InvalidPaginationToken(
String::from(parsed_error.message),
);
}
"NoSuchHostedZone" => {
return ListVPCAssociationAuthorizationsError::NoSuchHostedZone(
String::from(parsed_error.message),
);
}
_ => {}
}
}
}
ListVPCAssociationAuthorizationsError::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 ListVPCAssociationAuthorizationsError {
fn from(err: XmlParseError) -> ListVPCAssociationAuthorizationsError {
let XmlParseError(message) = err;
ListVPCAssociationAuthorizationsError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for ListVPCAssociationAuthorizationsError {
fn from(err: CredentialsError) -> ListVPCAssociationAuthorizationsError {
ListVPCAssociationAuthorizationsError::Credentials(err)
}
}
impl From<HttpDispatchError> for ListVPCAssociationAuthorizationsError {
fn from(err: HttpDispatchError) -> ListVPCAssociationAuthorizationsError {
ListVPCAssociationAuthorizationsError::HttpDispatch(err)
}
}
impl From<io::Error> for ListVPCAssociationAuthorizationsError {
fn from(err: io::Error) -> ListVPCAssociationAuthorizationsError {
ListVPCAssociationAuthorizationsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ListVPCAssociationAuthorizationsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ListVPCAssociationAuthorizationsError {
fn description(&self) -> &str {
match *self {
ListVPCAssociationAuthorizationsError::InvalidInput(ref cause) => cause,
ListVPCAssociationAuthorizationsError::InvalidPaginationToken(ref cause) => cause,
ListVPCAssociationAuthorizationsError::NoSuchHostedZone(ref cause) => cause,
ListVPCAssociationAuthorizationsError::Validation(ref cause) => cause,
ListVPCAssociationAuthorizationsError::Credentials(ref err) => err.description(),
ListVPCAssociationAuthorizationsError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
ListVPCAssociationAuthorizationsError::ParseError(ref cause) => cause,
ListVPCAssociationAuthorizationsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum TestDNSAnswerError {
InvalidInput(String),
NoSuchHostedZone(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl TestDNSAnswerError {
pub fn from_response(res: BufferedHttpResponse) -> TestDNSAnswerError {
{
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[..] {
"InvalidInput" => {
return TestDNSAnswerError::InvalidInput(String::from(parsed_error.message));
}
"NoSuchHostedZone" => {
return TestDNSAnswerError::NoSuchHostedZone(String::from(
parsed_error.message,
));
}
_ => {}
}
}
}
TestDNSAnswerError::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 TestDNSAnswerError {
fn from(err: XmlParseError) -> TestDNSAnswerError {
let XmlParseError(message) = err;
TestDNSAnswerError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for TestDNSAnswerError {
fn from(err: CredentialsError) -> TestDNSAnswerError {
TestDNSAnswerError::Credentials(err)
}
}
impl From<HttpDispatchError> for TestDNSAnswerError {
fn from(err: HttpDispatchError) -> TestDNSAnswerError {
TestDNSAnswerError::HttpDispatch(err)
}
}
impl From<io::Error> for TestDNSAnswerError {
fn from(err: io::Error) -> TestDNSAnswerError {
TestDNSAnswerError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for TestDNSAnswerError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for TestDNSAnswerError {
fn description(&self) -> &str {
match *self {
TestDNSAnswerError::InvalidInput(ref cause) => cause,
TestDNSAnswerError::NoSuchHostedZone(ref cause) => cause,
TestDNSAnswerError::Validation(ref cause) => cause,
TestDNSAnswerError::Credentials(ref err) => err.description(),
TestDNSAnswerError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
TestDNSAnswerError::ParseError(ref cause) => cause,
TestDNSAnswerError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum UpdateHealthCheckError {
HealthCheckVersionMismatch(String),
InvalidInput(String),
NoSuchHealthCheck(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl UpdateHealthCheckError {
pub fn from_response(res: BufferedHttpResponse) -> UpdateHealthCheckError {
{
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[..] {
"HealthCheckVersionMismatch" => {
return UpdateHealthCheckError::HealthCheckVersionMismatch(String::from(
parsed_error.message,
));
}
"InvalidInput" => {
return UpdateHealthCheckError::InvalidInput(String::from(
parsed_error.message,
));
}
"NoSuchHealthCheck" => {
return UpdateHealthCheckError::NoSuchHealthCheck(String::from(
parsed_error.message,
));
}
_ => {}
}
}
}
UpdateHealthCheckError::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 UpdateHealthCheckError {
fn from(err: XmlParseError) -> UpdateHealthCheckError {
let XmlParseError(message) = err;
UpdateHealthCheckError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for UpdateHealthCheckError {
fn from(err: CredentialsError) -> UpdateHealthCheckError {
UpdateHealthCheckError::Credentials(err)
}
}
impl From<HttpDispatchError> for UpdateHealthCheckError {
fn from(err: HttpDispatchError) -> UpdateHealthCheckError {
UpdateHealthCheckError::HttpDispatch(err)
}
}
impl From<io::Error> for UpdateHealthCheckError {
fn from(err: io::Error) -> UpdateHealthCheckError {
UpdateHealthCheckError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for UpdateHealthCheckError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for UpdateHealthCheckError {
fn description(&self) -> &str {
match *self {
UpdateHealthCheckError::HealthCheckVersionMismatch(ref cause) => cause,
UpdateHealthCheckError::InvalidInput(ref cause) => cause,
UpdateHealthCheckError::NoSuchHealthCheck(ref cause) => cause,
UpdateHealthCheckError::Validation(ref cause) => cause,
UpdateHealthCheckError::Credentials(ref err) => err.description(),
UpdateHealthCheckError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
UpdateHealthCheckError::ParseError(ref cause) => cause,
UpdateHealthCheckError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum UpdateHostedZoneCommentError {
InvalidInput(String),
NoSuchHostedZone(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl UpdateHostedZoneCommentError {
pub fn from_response(res: BufferedHttpResponse) -> UpdateHostedZoneCommentError {
{
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[..] {
"InvalidInput" => {
return UpdateHostedZoneCommentError::InvalidInput(String::from(
parsed_error.message,
));
}
"NoSuchHostedZone" => {
return UpdateHostedZoneCommentError::NoSuchHostedZone(String::from(
parsed_error.message,
));
}
_ => {}
}
}
}
UpdateHostedZoneCommentError::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 UpdateHostedZoneCommentError {
fn from(err: XmlParseError) -> UpdateHostedZoneCommentError {
let XmlParseError(message) = err;
UpdateHostedZoneCommentError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for UpdateHostedZoneCommentError {
fn from(err: CredentialsError) -> UpdateHostedZoneCommentError {
UpdateHostedZoneCommentError::Credentials(err)
}
}
impl From<HttpDispatchError> for UpdateHostedZoneCommentError {
fn from(err: HttpDispatchError) -> UpdateHostedZoneCommentError {
UpdateHostedZoneCommentError::HttpDispatch(err)
}
}
impl From<io::Error> for UpdateHostedZoneCommentError {
fn from(err: io::Error) -> UpdateHostedZoneCommentError {
UpdateHostedZoneCommentError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for UpdateHostedZoneCommentError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for UpdateHostedZoneCommentError {
fn description(&self) -> &str {
match *self {
UpdateHostedZoneCommentError::InvalidInput(ref cause) => cause,
UpdateHostedZoneCommentError::NoSuchHostedZone(ref cause) => cause,
UpdateHostedZoneCommentError::Validation(ref cause) => cause,
UpdateHostedZoneCommentError::Credentials(ref err) => err.description(),
UpdateHostedZoneCommentError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
UpdateHostedZoneCommentError::ParseError(ref cause) => cause,
UpdateHostedZoneCommentError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum UpdateTrafficPolicyCommentError {
ConcurrentModification(String),
InvalidInput(String),
NoSuchTrafficPolicy(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl UpdateTrafficPolicyCommentError {
pub fn from_response(res: BufferedHttpResponse) -> UpdateTrafficPolicyCommentError {
{
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[..] {
"ConcurrentModification" => {
return UpdateTrafficPolicyCommentError::ConcurrentModification(
String::from(parsed_error.message),
);
}
"InvalidInput" => {
return UpdateTrafficPolicyCommentError::InvalidInput(String::from(
parsed_error.message,
));
}
"NoSuchTrafficPolicy" => {
return UpdateTrafficPolicyCommentError::NoSuchTrafficPolicy(String::from(
parsed_error.message,
));
}
_ => {}
}
}
}
UpdateTrafficPolicyCommentError::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 UpdateTrafficPolicyCommentError {
fn from(err: XmlParseError) -> UpdateTrafficPolicyCommentError {
let XmlParseError(message) = err;
UpdateTrafficPolicyCommentError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for UpdateTrafficPolicyCommentError {
fn from(err: CredentialsError) -> UpdateTrafficPolicyCommentError {
UpdateTrafficPolicyCommentError::Credentials(err)
}
}
impl From<HttpDispatchError> for UpdateTrafficPolicyCommentError {
fn from(err: HttpDispatchError) -> UpdateTrafficPolicyCommentError {
UpdateTrafficPolicyCommentError::HttpDispatch(err)
}
}
impl From<io::Error> for UpdateTrafficPolicyCommentError {
fn from(err: io::Error) -> UpdateTrafficPolicyCommentError {
UpdateTrafficPolicyCommentError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for UpdateTrafficPolicyCommentError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for UpdateTrafficPolicyCommentError {
fn description(&self) -> &str {
match *self {
UpdateTrafficPolicyCommentError::ConcurrentModification(ref cause) => cause,
UpdateTrafficPolicyCommentError::InvalidInput(ref cause) => cause,
UpdateTrafficPolicyCommentError::NoSuchTrafficPolicy(ref cause) => cause,
UpdateTrafficPolicyCommentError::Validation(ref cause) => cause,
UpdateTrafficPolicyCommentError::Credentials(ref err) => err.description(),
UpdateTrafficPolicyCommentError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
UpdateTrafficPolicyCommentError::ParseError(ref cause) => cause,
UpdateTrafficPolicyCommentError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum UpdateTrafficPolicyInstanceError {
ConflictingTypes(String),
InvalidInput(String),
NoSuchTrafficPolicy(String),
NoSuchTrafficPolicyInstance(String),
PriorRequestNotComplete(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl UpdateTrafficPolicyInstanceError {
pub fn from_response(res: BufferedHttpResponse) -> UpdateTrafficPolicyInstanceError {
{
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[..] {
"ConflictingTypes" => {
return UpdateTrafficPolicyInstanceError::ConflictingTypes(String::from(
parsed_error.message,
));
}
"InvalidInput" => {
return UpdateTrafficPolicyInstanceError::InvalidInput(String::from(
parsed_error.message,
));
}
"NoSuchTrafficPolicy" => {
return UpdateTrafficPolicyInstanceError::NoSuchTrafficPolicy(String::from(
parsed_error.message,
));
}
"NoSuchTrafficPolicyInstance" => {
return UpdateTrafficPolicyInstanceError::NoSuchTrafficPolicyInstance(
String::from(parsed_error.message),
);
}
"PriorRequestNotComplete" => {
return UpdateTrafficPolicyInstanceError::PriorRequestNotComplete(
String::from(parsed_error.message),
);
}
_ => {}
}
}
}
UpdateTrafficPolicyInstanceError::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 UpdateTrafficPolicyInstanceError {
fn from(err: XmlParseError) -> UpdateTrafficPolicyInstanceError {
let XmlParseError(message) = err;
UpdateTrafficPolicyInstanceError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for UpdateTrafficPolicyInstanceError {
fn from(err: CredentialsError) -> UpdateTrafficPolicyInstanceError {
UpdateTrafficPolicyInstanceError::Credentials(err)
}
}
impl From<HttpDispatchError> for UpdateTrafficPolicyInstanceError {
fn from(err: HttpDispatchError) -> UpdateTrafficPolicyInstanceError {
UpdateTrafficPolicyInstanceError::HttpDispatch(err)
}
}
impl From<io::Error> for UpdateTrafficPolicyInstanceError {
fn from(err: io::Error) -> UpdateTrafficPolicyInstanceError {
UpdateTrafficPolicyInstanceError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for UpdateTrafficPolicyInstanceError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for UpdateTrafficPolicyInstanceError {
fn description(&self) -> &str {
match *self {
UpdateTrafficPolicyInstanceError::ConflictingTypes(ref cause) => cause,
UpdateTrafficPolicyInstanceError::InvalidInput(ref cause) => cause,
UpdateTrafficPolicyInstanceError::NoSuchTrafficPolicy(ref cause) => cause,
UpdateTrafficPolicyInstanceError::NoSuchTrafficPolicyInstance(ref cause) => cause,
UpdateTrafficPolicyInstanceError::PriorRequestNotComplete(ref cause) => cause,
UpdateTrafficPolicyInstanceError::Validation(ref cause) => cause,
UpdateTrafficPolicyInstanceError::Credentials(ref err) => err.description(),
UpdateTrafficPolicyInstanceError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
UpdateTrafficPolicyInstanceError::ParseError(ref cause) => cause,
UpdateTrafficPolicyInstanceError::Unknown(_) => "unknown error",
}
}
}
pub trait Route53 {
fn associate_vpc_with_hosted_zone(
&self,
input: AssociateVPCWithHostedZoneRequest,
) -> RusotoFuture<AssociateVPCWithHostedZoneResponse, AssociateVPCWithHostedZoneError>;
fn change_resource_record_sets(
&self,
input: ChangeResourceRecordSetsRequest,
) -> RusotoFuture<ChangeResourceRecordSetsResponse, ChangeResourceRecordSetsError>;
fn change_tags_for_resource(
&self,
input: ChangeTagsForResourceRequest,
) -> RusotoFuture<ChangeTagsForResourceResponse, ChangeTagsForResourceError>;
fn create_health_check(
&self,
input: CreateHealthCheckRequest,
) -> RusotoFuture<CreateHealthCheckResponse, CreateHealthCheckError>;
fn create_hosted_zone(
&self,
input: CreateHostedZoneRequest,
) -> RusotoFuture<CreateHostedZoneResponse, CreateHostedZoneError>;
fn create_query_logging_config(
&self,
input: CreateQueryLoggingConfigRequest,
) -> RusotoFuture<CreateQueryLoggingConfigResponse, CreateQueryLoggingConfigError>;
fn create_reusable_delegation_set(
&self,
input: CreateReusableDelegationSetRequest,
) -> RusotoFuture<CreateReusableDelegationSetResponse, CreateReusableDelegationSetError>;
fn create_traffic_policy(
&self,
input: CreateTrafficPolicyRequest,
) -> RusotoFuture<CreateTrafficPolicyResponse, CreateTrafficPolicyError>;
fn create_traffic_policy_instance(
&self,
input: CreateTrafficPolicyInstanceRequest,
) -> RusotoFuture<CreateTrafficPolicyInstanceResponse, CreateTrafficPolicyInstanceError>;
fn create_traffic_policy_version(
&self,
input: CreateTrafficPolicyVersionRequest,
) -> RusotoFuture<CreateTrafficPolicyVersionResponse, CreateTrafficPolicyVersionError>;
fn create_vpc_association_authorization(
&self,
input: CreateVPCAssociationAuthorizationRequest,
) -> RusotoFuture<
CreateVPCAssociationAuthorizationResponse,
CreateVPCAssociationAuthorizationError,
>;
fn delete_health_check(
&self,
input: DeleteHealthCheckRequest,
) -> RusotoFuture<DeleteHealthCheckResponse, DeleteHealthCheckError>;
fn delete_hosted_zone(
&self,
input: DeleteHostedZoneRequest,
) -> RusotoFuture<DeleteHostedZoneResponse, DeleteHostedZoneError>;
fn delete_query_logging_config(
&self,
input: DeleteQueryLoggingConfigRequest,
) -> RusotoFuture<DeleteQueryLoggingConfigResponse, DeleteQueryLoggingConfigError>;
fn delete_reusable_delegation_set(
&self,
input: DeleteReusableDelegationSetRequest,
) -> RusotoFuture<DeleteReusableDelegationSetResponse, DeleteReusableDelegationSetError>;
fn delete_traffic_policy(
&self,
input: DeleteTrafficPolicyRequest,
) -> RusotoFuture<DeleteTrafficPolicyResponse, DeleteTrafficPolicyError>;
fn delete_traffic_policy_instance(
&self,
input: DeleteTrafficPolicyInstanceRequest,
) -> RusotoFuture<DeleteTrafficPolicyInstanceResponse, DeleteTrafficPolicyInstanceError>;
fn delete_vpc_association_authorization(
&self,
input: DeleteVPCAssociationAuthorizationRequest,
) -> RusotoFuture<
DeleteVPCAssociationAuthorizationResponse,
DeleteVPCAssociationAuthorizationError,
>;
fn disassociate_vpc_from_hosted_zone(
&self,
input: DisassociateVPCFromHostedZoneRequest,
) -> RusotoFuture<DisassociateVPCFromHostedZoneResponse, DisassociateVPCFromHostedZoneError>;
fn get_account_limit(
&self,
input: GetAccountLimitRequest,
) -> RusotoFuture<GetAccountLimitResponse, GetAccountLimitError>;
fn get_change(
&self,
input: GetChangeRequest,
) -> RusotoFuture<GetChangeResponse, GetChangeError>;
fn get_checker_ip_ranges(
&self,
input: GetCheckerIpRangesRequest,
) -> RusotoFuture<GetCheckerIpRangesResponse, GetCheckerIpRangesError>;
fn get_geo_location(
&self,
input: GetGeoLocationRequest,
) -> RusotoFuture<GetGeoLocationResponse, GetGeoLocationError>;
fn get_health_check(
&self,
input: GetHealthCheckRequest,
) -> RusotoFuture<GetHealthCheckResponse, GetHealthCheckError>;
fn get_health_check_count(
&self,
input: GetHealthCheckCountRequest,
) -> RusotoFuture<GetHealthCheckCountResponse, GetHealthCheckCountError>;
fn get_health_check_last_failure_reason(
&self,
input: GetHealthCheckLastFailureReasonRequest,
) -> RusotoFuture<GetHealthCheckLastFailureReasonResponse, GetHealthCheckLastFailureReasonError>;
fn get_health_check_status(
&self,
input: GetHealthCheckStatusRequest,
) -> RusotoFuture<GetHealthCheckStatusResponse, GetHealthCheckStatusError>;
fn get_hosted_zone(
&self,
input: GetHostedZoneRequest,
) -> RusotoFuture<GetHostedZoneResponse, GetHostedZoneError>;
fn get_hosted_zone_count(
&self,
input: GetHostedZoneCountRequest,
) -> RusotoFuture<GetHostedZoneCountResponse, GetHostedZoneCountError>;
fn get_hosted_zone_limit(
&self,
input: GetHostedZoneLimitRequest,
) -> RusotoFuture<GetHostedZoneLimitResponse, GetHostedZoneLimitError>;
fn get_query_logging_config(
&self,
input: GetQueryLoggingConfigRequest,
) -> RusotoFuture<GetQueryLoggingConfigResponse, GetQueryLoggingConfigError>;
fn get_reusable_delegation_set(
&self,
input: GetReusableDelegationSetRequest,
) -> RusotoFuture<GetReusableDelegationSetResponse, GetReusableDelegationSetError>;
fn get_reusable_delegation_set_limit(
&self,
input: GetReusableDelegationSetLimitRequest,
) -> RusotoFuture<GetReusableDelegationSetLimitResponse, GetReusableDelegationSetLimitError>;
fn get_traffic_policy(
&self,
input: GetTrafficPolicyRequest,
) -> RusotoFuture<GetTrafficPolicyResponse, GetTrafficPolicyError>;
fn get_traffic_policy_instance(
&self,
input: GetTrafficPolicyInstanceRequest,
) -> RusotoFuture<GetTrafficPolicyInstanceResponse, GetTrafficPolicyInstanceError>;
fn get_traffic_policy_instance_count(
&self,
input: GetTrafficPolicyInstanceCountRequest,
) -> RusotoFuture<GetTrafficPolicyInstanceCountResponse, GetTrafficPolicyInstanceCountError>;
fn list_geo_locations(
&self,
input: ListGeoLocationsRequest,
) -> RusotoFuture<ListGeoLocationsResponse, ListGeoLocationsError>;
fn list_health_checks(
&self,
input: ListHealthChecksRequest,
) -> RusotoFuture<ListHealthChecksResponse, ListHealthChecksError>;
fn list_hosted_zones(
&self,
input: ListHostedZonesRequest,
) -> RusotoFuture<ListHostedZonesResponse, ListHostedZonesError>;
fn list_hosted_zones_by_name(
&self,
input: ListHostedZonesByNameRequest,
) -> RusotoFuture<ListHostedZonesByNameResponse, ListHostedZonesByNameError>;
fn list_query_logging_configs(
&self,
input: ListQueryLoggingConfigsRequest,
) -> RusotoFuture<ListQueryLoggingConfigsResponse, ListQueryLoggingConfigsError>;
fn list_resource_record_sets(
&self,
input: ListResourceRecordSetsRequest,
) -> RusotoFuture<ListResourceRecordSetsResponse, ListResourceRecordSetsError>;
fn list_reusable_delegation_sets(
&self,
input: ListReusableDelegationSetsRequest,
) -> RusotoFuture<ListReusableDelegationSetsResponse, ListReusableDelegationSetsError>;
fn list_tags_for_resource(
&self,
input: ListTagsForResourceRequest,
) -> RusotoFuture<ListTagsForResourceResponse, ListTagsForResourceError>;
fn list_tags_for_resources(
&self,
input: ListTagsForResourcesRequest,
) -> RusotoFuture<ListTagsForResourcesResponse, ListTagsForResourcesError>;
fn list_traffic_policies(
&self,
input: ListTrafficPoliciesRequest,
) -> RusotoFuture<ListTrafficPoliciesResponse, ListTrafficPoliciesError>;
fn list_traffic_policy_instances(
&self,
input: ListTrafficPolicyInstancesRequest,
) -> RusotoFuture<ListTrafficPolicyInstancesResponse, ListTrafficPolicyInstancesError>;
fn list_traffic_policy_instances_by_hosted_zone(
&self,
input: ListTrafficPolicyInstancesByHostedZoneRequest,
) -> RusotoFuture<
ListTrafficPolicyInstancesByHostedZoneResponse,
ListTrafficPolicyInstancesByHostedZoneError,
>;
fn list_traffic_policy_instances_by_policy(
&self,
input: ListTrafficPolicyInstancesByPolicyRequest,
) -> RusotoFuture<
ListTrafficPolicyInstancesByPolicyResponse,
ListTrafficPolicyInstancesByPolicyError,
>;
fn list_traffic_policy_versions(
&self,
input: ListTrafficPolicyVersionsRequest,
) -> RusotoFuture<ListTrafficPolicyVersionsResponse, ListTrafficPolicyVersionsError>;
fn list_vpc_association_authorizations(
&self,
input: ListVPCAssociationAuthorizationsRequest,
) -> RusotoFuture<ListVPCAssociationAuthorizationsResponse, ListVPCAssociationAuthorizationsError>;
fn test_dns_answer(
&self,
input: TestDNSAnswerRequest,
) -> RusotoFuture<TestDNSAnswerResponse, TestDNSAnswerError>;
fn update_health_check(
&self,
input: UpdateHealthCheckRequest,
) -> RusotoFuture<UpdateHealthCheckResponse, UpdateHealthCheckError>;
fn update_hosted_zone_comment(
&self,
input: UpdateHostedZoneCommentRequest,
) -> RusotoFuture<UpdateHostedZoneCommentResponse, UpdateHostedZoneCommentError>;
fn update_traffic_policy_comment(
&self,
input: UpdateTrafficPolicyCommentRequest,
) -> RusotoFuture<UpdateTrafficPolicyCommentResponse, UpdateTrafficPolicyCommentError>;
fn update_traffic_policy_instance(
&self,
input: UpdateTrafficPolicyInstanceRequest,
) -> RusotoFuture<UpdateTrafficPolicyInstanceResponse, UpdateTrafficPolicyInstanceError>;
}
#[derive(Clone)]
pub struct Route53Client {
client: Client,
region: region::Region,
}
impl Route53Client {
pub fn new(region: region::Region) -> Route53Client {
Route53Client {
client: Client::shared(),
region: region,
}
}
pub fn new_with<P, D>(
request_dispatcher: D,
credentials_provider: P,
region: region::Region,
) -> Route53Client
where
P: ProvideAwsCredentials + Send + Sync + 'static,
P::Future: Send,
D: DispatchSignedRequest + Send + Sync + 'static,
D::Future: Send,
{
Route53Client {
client: Client::new_with(credentials_provider, request_dispatcher),
region: region,
}
}
}
impl Route53 for Route53Client {
#[allow(unused_variables, warnings)]
fn associate_vpc_with_hosted_zone(
&self,
input: AssociateVPCWithHostedZoneRequest,
) -> RusotoFuture<AssociateVPCWithHostedZoneResponse, AssociateVPCWithHostedZoneError> {
let request_uri = format!(
"/2013-04-01/hostedzone/{id}/associatevpc",
id = input.hosted_zone_id
)
.replace("/hostedzone/hostedzone/", "/hostedzone/")
.replace("/change/change/", "/change/");
let mut request = SignedRequest::new("POST", "route53", &self.region, &request_uri);
let mut writer = EventWriter::new(Vec::new());
AssociateVPCWithHostedZoneRequestSerializer::serialize(
&mut writer,
"AssociateVPCWithHostedZoneRequest",
&input,
"https://route53.amazonaws.com/doc/2013-04-01/",
);
request.set_payload(Some(writer.into_inner()));
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(AssociateVPCWithHostedZoneError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let mut result;
if response.body.is_empty() {
result = AssociateVPCWithHostedZoneResponse::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 = peek_at_name(&mut stack)?;
result = AssociateVPCWithHostedZoneResponseDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
#[allow(unused_variables, warnings)]
fn change_resource_record_sets(
&self,
input: ChangeResourceRecordSetsRequest,
) -> RusotoFuture<ChangeResourceRecordSetsResponse, ChangeResourceRecordSetsError> {
let request_uri = format!(
"/2013-04-01/hostedzone/{id}/rrset/",
id = input.hosted_zone_id
)
.replace("/hostedzone/hostedzone/", "/hostedzone/")
.replace("/change/change/", "/change/");
let mut request = SignedRequest::new("POST", "route53", &self.region, &request_uri);
let mut writer = EventWriter::new(Vec::new());
ChangeResourceRecordSetsRequestSerializer::serialize(
&mut writer,
"ChangeResourceRecordSetsRequest",
&input,
"https://route53.amazonaws.com/doc/2013-04-01/",
);
request.set_payload(Some(writer.into_inner()));
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(ChangeResourceRecordSetsError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let mut result;
if response.body.is_empty() {
result = ChangeResourceRecordSetsResponse::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 = peek_at_name(&mut stack)?;
result = ChangeResourceRecordSetsResponseDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
#[allow(unused_variables, warnings)]
fn change_tags_for_resource(
&self,
input: ChangeTagsForResourceRequest,
) -> RusotoFuture<ChangeTagsForResourceResponse, ChangeTagsForResourceError> {
let request_uri = format!(
"/2013-04-01/tags/{resource_type}/{resource_id}",
resource_id = input.resource_id,
resource_type = input.resource_type
)
.replace("/hostedzone/hostedzone/", "/hostedzone/")
.replace("/change/change/", "/change/");
let mut request = SignedRequest::new("POST", "route53", &self.region, &request_uri);
let mut writer = EventWriter::new(Vec::new());
ChangeTagsForResourceRequestSerializer::serialize(
&mut writer,
"ChangeTagsForResourceRequest",
&input,
"https://route53.amazonaws.com/doc/2013-04-01/",
);
request.set_payload(Some(writer.into_inner()));
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response.buffer().from_err().and_then(|response| {
Err(ChangeTagsForResourceError::from_response(response))
}),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let mut result;
if response.body.is_empty() {
result = ChangeTagsForResourceResponse::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 = peek_at_name(&mut stack)?;
result = ChangeTagsForResourceResponseDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
#[allow(unused_variables, warnings)]
fn create_health_check(
&self,
input: CreateHealthCheckRequest,
) -> RusotoFuture<CreateHealthCheckResponse, CreateHealthCheckError> {
let request_uri = "/2013-04-01/healthcheck";
let mut request = SignedRequest::new("POST", "route53", &self.region, &request_uri);
let mut writer = EventWriter::new(Vec::new());
CreateHealthCheckRequestSerializer::serialize(
&mut writer,
"CreateHealthCheckRequest",
&input,
"https://route53.amazonaws.com/doc/2013-04-01/",
);
request.set_payload(Some(writer.into_inner()));
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(CreateHealthCheckError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let mut result;
if response.body.is_empty() {
result = CreateHealthCheckResponse::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 = peek_at_name(&mut stack)?;
result = CreateHealthCheckResponseDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
let value = response.headers.get("Location").unwrap().to_owned();
result.location = value;
Ok(result)
}))
})
}
#[allow(unused_variables, warnings)]
fn create_hosted_zone(
&self,
input: CreateHostedZoneRequest,
) -> RusotoFuture<CreateHostedZoneResponse, CreateHostedZoneError> {
let request_uri = "/2013-04-01/hostedzone";
let mut request = SignedRequest::new("POST", "route53", &self.region, &request_uri);
let mut writer = EventWriter::new(Vec::new());
CreateHostedZoneRequestSerializer::serialize(
&mut writer,
"CreateHostedZoneRequest",
&input,
"https://route53.amazonaws.com/doc/2013-04-01/",
);
request.set_payload(Some(writer.into_inner()));
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(CreateHostedZoneError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let mut result;
if response.body.is_empty() {
result = CreateHostedZoneResponse::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 = peek_at_name(&mut stack)?;
result = CreateHostedZoneResponseDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
let value = response.headers.get("Location").unwrap().to_owned();
result.location = value;
Ok(result)
}))
})
}
#[allow(unused_variables, warnings)]
fn create_query_logging_config(
&self,
input: CreateQueryLoggingConfigRequest,
) -> RusotoFuture<CreateQueryLoggingConfigResponse, CreateQueryLoggingConfigError> {
let request_uri = "/2013-04-01/queryloggingconfig";
let mut request = SignedRequest::new("POST", "route53", &self.region, &request_uri);
let mut writer = EventWriter::new(Vec::new());
CreateQueryLoggingConfigRequestSerializer::serialize(
&mut writer,
"CreateQueryLoggingConfigRequest",
&input,
"https://route53.amazonaws.com/doc/2013-04-01/",
);
request.set_payload(Some(writer.into_inner()));
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(CreateQueryLoggingConfigError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let mut result;
if response.body.is_empty() {
result = CreateQueryLoggingConfigResponse::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 = peek_at_name(&mut stack)?;
result = CreateQueryLoggingConfigResponseDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
let value = response.headers.get("Location").unwrap().to_owned();
result.location = value;
Ok(result)
}))
})
}
#[allow(unused_variables, warnings)]
fn create_reusable_delegation_set(
&self,
input: CreateReusableDelegationSetRequest,
) -> RusotoFuture<CreateReusableDelegationSetResponse, CreateReusableDelegationSetError> {
let request_uri = "/2013-04-01/delegationset";
let mut request = SignedRequest::new("POST", "route53", &self.region, &request_uri);
let mut writer = EventWriter::new(Vec::new());
CreateReusableDelegationSetRequestSerializer::serialize(
&mut writer,
"CreateReusableDelegationSetRequest",
&input,
"https://route53.amazonaws.com/doc/2013-04-01/",
);
request.set_payload(Some(writer.into_inner()));
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(CreateReusableDelegationSetError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let mut result;
if response.body.is_empty() {
result = CreateReusableDelegationSetResponse::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 = peek_at_name(&mut stack)?;
result = CreateReusableDelegationSetResponseDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
let value = response.headers.get("Location").unwrap().to_owned();
result.location = value;
Ok(result)
}))
})
}
#[allow(unused_variables, warnings)]
fn create_traffic_policy(
&self,
input: CreateTrafficPolicyRequest,
) -> RusotoFuture<CreateTrafficPolicyResponse, CreateTrafficPolicyError> {
let request_uri = "/2013-04-01/trafficpolicy";
let mut request = SignedRequest::new("POST", "route53", &self.region, &request_uri);
let mut writer = EventWriter::new(Vec::new());
CreateTrafficPolicyRequestSerializer::serialize(
&mut writer,
"CreateTrafficPolicyRequest",
&input,
"https://route53.amazonaws.com/doc/2013-04-01/",
);
request.set_payload(Some(writer.into_inner()));
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response.buffer().from_err().and_then(|response| {
Err(CreateTrafficPolicyError::from_response(response))
}),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let mut result;
if response.body.is_empty() {
result = CreateTrafficPolicyResponse::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 = peek_at_name(&mut stack)?;
result = CreateTrafficPolicyResponseDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
let value = response.headers.get("Location").unwrap().to_owned();
result.location = value;
Ok(result)
}))
})
}
#[allow(unused_variables, warnings)]
fn create_traffic_policy_instance(
&self,
input: CreateTrafficPolicyInstanceRequest,
) -> RusotoFuture<CreateTrafficPolicyInstanceResponse, CreateTrafficPolicyInstanceError> {
let request_uri = "/2013-04-01/trafficpolicyinstance";
let mut request = SignedRequest::new("POST", "route53", &self.region, &request_uri);
let mut writer = EventWriter::new(Vec::new());
CreateTrafficPolicyInstanceRequestSerializer::serialize(
&mut writer,
"CreateTrafficPolicyInstanceRequest",
&input,
"https://route53.amazonaws.com/doc/2013-04-01/",
);
request.set_payload(Some(writer.into_inner()));
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(CreateTrafficPolicyInstanceError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let mut result;
if response.body.is_empty() {
result = CreateTrafficPolicyInstanceResponse::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 = peek_at_name(&mut stack)?;
result = CreateTrafficPolicyInstanceResponseDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
let value = response.headers.get("Location").unwrap().to_owned();
result.location = value;
Ok(result)
}))
})
}
#[allow(unused_variables, warnings)]
fn create_traffic_policy_version(
&self,
input: CreateTrafficPolicyVersionRequest,
) -> RusotoFuture<CreateTrafficPolicyVersionResponse, CreateTrafficPolicyVersionError> {
let request_uri = format!("/2013-04-01/trafficpolicy/{id}", id = input.id)
.replace("/hostedzone/hostedzone/", "/hostedzone/")
.replace("/change/change/", "/change/");
let mut request = SignedRequest::new("POST", "route53", &self.region, &request_uri);
let mut writer = EventWriter::new(Vec::new());
CreateTrafficPolicyVersionRequestSerializer::serialize(
&mut writer,
"CreateTrafficPolicyVersionRequest",
&input,
"https://route53.amazonaws.com/doc/2013-04-01/",
);
request.set_payload(Some(writer.into_inner()));
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(CreateTrafficPolicyVersionError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let mut result;
if response.body.is_empty() {
result = CreateTrafficPolicyVersionResponse::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 = peek_at_name(&mut stack)?;
result = CreateTrafficPolicyVersionResponseDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
let value = response.headers.get("Location").unwrap().to_owned();
result.location = value;
Ok(result)
}))
})
}
#[allow(unused_variables, warnings)]
fn create_vpc_association_authorization(
&self,
input: CreateVPCAssociationAuthorizationRequest,
) -> RusotoFuture<
CreateVPCAssociationAuthorizationResponse,
CreateVPCAssociationAuthorizationError,
> {
let request_uri = format!(
"/2013-04-01/hostedzone/{id}/authorizevpcassociation",
id = input.hosted_zone_id
)
.replace("/hostedzone/hostedzone/", "/hostedzone/")
.replace("/change/change/", "/change/");
let mut request = SignedRequest::new("POST", "route53", &self.region, &request_uri);
let mut writer = EventWriter::new(Vec::new());
CreateVPCAssociationAuthorizationRequestSerializer::serialize(
&mut writer,
"CreateVPCAssociationAuthorizationRequest",
&input,
"https://route53.amazonaws.com/doc/2013-04-01/",
);
request.set_payload(Some(writer.into_inner()));
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(CreateVPCAssociationAuthorizationError::from_response(
response,
))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let mut result;
if response.body.is_empty() {
result = CreateVPCAssociationAuthorizationResponse::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 = peek_at_name(&mut stack)?;
result = CreateVPCAssociationAuthorizationResponseDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
#[allow(unused_variables, warnings)]
fn delete_health_check(
&self,
input: DeleteHealthCheckRequest,
) -> RusotoFuture<DeleteHealthCheckResponse, DeleteHealthCheckError> {
let request_uri = format!(
"/2013-04-01/healthcheck/{health_check_id}",
health_check_id = input.health_check_id
)
.replace("/hostedzone/hostedzone/", "/hostedzone/")
.replace("/change/change/", "/change/");
let mut request = SignedRequest::new("DELETE", "route53", &self.region, &request_uri);
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DeleteHealthCheckError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let mut result;
if response.body.is_empty() {
result = DeleteHealthCheckResponse::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 = peek_at_name(&mut stack)?;
result = DeleteHealthCheckResponseDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
#[allow(unused_variables, warnings)]
fn delete_hosted_zone(
&self,
input: DeleteHostedZoneRequest,
) -> RusotoFuture<DeleteHostedZoneResponse, DeleteHostedZoneError> {
let request_uri = format!("/2013-04-01/hostedzone/{id}", id = input.id)
.replace("/hostedzone/hostedzone/", "/hostedzone/")
.replace("/change/change/", "/change/");
let mut request = SignedRequest::new("DELETE", "route53", &self.region, &request_uri);
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DeleteHostedZoneError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let mut result;
if response.body.is_empty() {
result = DeleteHostedZoneResponse::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 = peek_at_name(&mut stack)?;
result = DeleteHostedZoneResponseDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
#[allow(unused_variables, warnings)]
fn delete_query_logging_config(
&self,
input: DeleteQueryLoggingConfigRequest,
) -> RusotoFuture<DeleteQueryLoggingConfigResponse, DeleteQueryLoggingConfigError> {
let request_uri = format!("/2013-04-01/queryloggingconfig/{id}", id = input.id)
.replace("/hostedzone/hostedzone/", "/hostedzone/")
.replace("/change/change/", "/change/");
let mut request = SignedRequest::new("DELETE", "route53", &self.region, &request_uri);
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DeleteQueryLoggingConfigError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let mut result;
if response.body.is_empty() {
result = DeleteQueryLoggingConfigResponse::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 = peek_at_name(&mut stack)?;
result = DeleteQueryLoggingConfigResponseDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
#[allow(unused_variables, warnings)]
fn delete_reusable_delegation_set(
&self,
input: DeleteReusableDelegationSetRequest,
) -> RusotoFuture<DeleteReusableDelegationSetResponse, DeleteReusableDelegationSetError> {
let request_uri = format!("/2013-04-01/delegationset/{id}", id = input.id)
.replace("/hostedzone/hostedzone/", "/hostedzone/")
.replace("/change/change/", "/change/");
let mut request = SignedRequest::new("DELETE", "route53", &self.region, &request_uri);
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DeleteReusableDelegationSetError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let mut result;
if response.body.is_empty() {
result = DeleteReusableDelegationSetResponse::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 = peek_at_name(&mut stack)?;
result = DeleteReusableDelegationSetResponseDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
#[allow(unused_variables, warnings)]
fn delete_traffic_policy(
&self,
input: DeleteTrafficPolicyRequest,
) -> RusotoFuture<DeleteTrafficPolicyResponse, DeleteTrafficPolicyError> {
let request_uri = format!(
"/2013-04-01/trafficpolicy/{id}/{version}",
id = input.id,
version = input.version
)
.replace("/hostedzone/hostedzone/", "/hostedzone/")
.replace("/change/change/", "/change/");
let mut request = SignedRequest::new("DELETE", "route53", &self.region, &request_uri);
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response.buffer().from_err().and_then(|response| {
Err(DeleteTrafficPolicyError::from_response(response))
}),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let mut result;
if response.body.is_empty() {
result = DeleteTrafficPolicyResponse::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 = peek_at_name(&mut stack)?;
result = DeleteTrafficPolicyResponseDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
#[allow(unused_variables, warnings)]
fn delete_traffic_policy_instance(
&self,
input: DeleteTrafficPolicyInstanceRequest,
) -> RusotoFuture<DeleteTrafficPolicyInstanceResponse, DeleteTrafficPolicyInstanceError> {
let request_uri = format!("/2013-04-01/trafficpolicyinstance/{id}", id = input.id)
.replace("/hostedzone/hostedzone/", "/hostedzone/")
.replace("/change/change/", "/change/");
let mut request = SignedRequest::new("DELETE", "route53", &self.region, &request_uri);
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DeleteTrafficPolicyInstanceError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let mut result;
if response.body.is_empty() {
result = DeleteTrafficPolicyInstanceResponse::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 = peek_at_name(&mut stack)?;
result = DeleteTrafficPolicyInstanceResponseDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
#[allow(unused_variables, warnings)]
fn delete_vpc_association_authorization(
&self,
input: DeleteVPCAssociationAuthorizationRequest,
) -> RusotoFuture<
DeleteVPCAssociationAuthorizationResponse,
DeleteVPCAssociationAuthorizationError,
> {
let request_uri = format!(
"/2013-04-01/hostedzone/{id}/deauthorizevpcassociation",
id = input.hosted_zone_id
)
.replace("/hostedzone/hostedzone/", "/hostedzone/")
.replace("/change/change/", "/change/");
let mut request = SignedRequest::new("POST", "route53", &self.region, &request_uri);
let mut writer = EventWriter::new(Vec::new());
DeleteVPCAssociationAuthorizationRequestSerializer::serialize(
&mut writer,
"DeleteVPCAssociationAuthorizationRequest",
&input,
"https://route53.amazonaws.com/doc/2013-04-01/",
);
request.set_payload(Some(writer.into_inner()));
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DeleteVPCAssociationAuthorizationError::from_response(
response,
))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let mut result;
if response.body.is_empty() {
result = DeleteVPCAssociationAuthorizationResponse::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 = peek_at_name(&mut stack)?;
result = DeleteVPCAssociationAuthorizationResponseDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
#[allow(unused_variables, warnings)]
fn disassociate_vpc_from_hosted_zone(
&self,
input: DisassociateVPCFromHostedZoneRequest,
) -> RusotoFuture<DisassociateVPCFromHostedZoneResponse, DisassociateVPCFromHostedZoneError>
{
let request_uri = format!(
"/2013-04-01/hostedzone/{id}/disassociatevpc",
id = input.hosted_zone_id
)
.replace("/hostedzone/hostedzone/", "/hostedzone/")
.replace("/change/change/", "/change/");
let mut request = SignedRequest::new("POST", "route53", &self.region, &request_uri);
let mut writer = EventWriter::new(Vec::new());
DisassociateVPCFromHostedZoneRequestSerializer::serialize(
&mut writer,
"DisassociateVPCFromHostedZoneRequest",
&input,
"https://route53.amazonaws.com/doc/2013-04-01/",
);
request.set_payload(Some(writer.into_inner()));
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DisassociateVPCFromHostedZoneError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let mut result;
if response.body.is_empty() {
result = DisassociateVPCFromHostedZoneResponse::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 = peek_at_name(&mut stack)?;
result = DisassociateVPCFromHostedZoneResponseDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
#[allow(unused_variables, warnings)]
fn get_account_limit(
&self,
input: GetAccountLimitRequest,
) -> RusotoFuture<GetAccountLimitResponse, GetAccountLimitError> {
let request_uri = format!("/2013-04-01/accountlimit/{type}", type = input.type_)
.replace("/hostedzone/hostedzone/", "/hostedzone/")
.replace("/change/change/", "/change/");
let mut request = SignedRequest::new("GET", "route53", &self.region, &request_uri);
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(GetAccountLimitError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let mut result;
if response.body.is_empty() {
result = GetAccountLimitResponse::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 = peek_at_name(&mut stack)?;
result = GetAccountLimitResponseDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
#[allow(unused_variables, warnings)]
fn get_change(
&self,
input: GetChangeRequest,
) -> RusotoFuture<GetChangeResponse, GetChangeError> {
let request_uri = format!("/2013-04-01/change/{id}", id = input.id)
.replace("/hostedzone/hostedzone/", "/hostedzone/")
.replace("/change/change/", "/change/");
let mut request = SignedRequest::new("GET", "route53", &self.region, &request_uri);
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(GetChangeError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let mut result;
if response.body.is_empty() {
result = GetChangeResponse::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 = peek_at_name(&mut stack)?;
result =
GetChangeResponseDeserializer::deserialize(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
#[allow(unused_variables, warnings)]
fn get_checker_ip_ranges(
&self,
input: GetCheckerIpRangesRequest,
) -> RusotoFuture<GetCheckerIpRangesResponse, GetCheckerIpRangesError> {
let request_uri = "/2013-04-01/checkeripranges";
let mut request = SignedRequest::new("GET", "route53", &self.region, &request_uri);
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(GetCheckerIpRangesError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let mut result;
if response.body.is_empty() {
result = GetCheckerIpRangesResponse::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 = peek_at_name(&mut stack)?;
result = GetCheckerIpRangesResponseDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
#[allow(unused_variables, warnings)]
fn get_geo_location(
&self,
input: GetGeoLocationRequest,
) -> RusotoFuture<GetGeoLocationResponse, GetGeoLocationError> {
let request_uri = "/2013-04-01/geolocation";
let mut request = SignedRequest::new("GET", "route53", &self.region, &request_uri);
let mut params = Params::new();
if let Some(ref x) = input.continent_code {
params.put("continentcode", x);
}
if let Some(ref x) = input.country_code {
params.put("countrycode", x);
}
if let Some(ref x) = input.subdivision_code {
params.put("subdivisioncode", x);
}
request.set_params(params);
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(GetGeoLocationError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let mut result;
if response.body.is_empty() {
result = GetGeoLocationResponse::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 = peek_at_name(&mut stack)?;
result = GetGeoLocationResponseDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
#[allow(unused_variables, warnings)]
fn get_health_check(
&self,
input: GetHealthCheckRequest,
) -> RusotoFuture<GetHealthCheckResponse, GetHealthCheckError> {
let request_uri = format!(
"/2013-04-01/healthcheck/{health_check_id}",
health_check_id = input.health_check_id
)
.replace("/hostedzone/hostedzone/", "/hostedzone/")
.replace("/change/change/", "/change/");
let mut request = SignedRequest::new("GET", "route53", &self.region, &request_uri);
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(GetHealthCheckError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let mut result;
if response.body.is_empty() {
result = GetHealthCheckResponse::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 = peek_at_name(&mut stack)?;
result = GetHealthCheckResponseDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
#[allow(unused_variables, warnings)]
fn get_health_check_count(
&self,
input: GetHealthCheckCountRequest,
) -> RusotoFuture<GetHealthCheckCountResponse, GetHealthCheckCountError> {
let request_uri = "/2013-04-01/healthcheckcount";
let mut request = SignedRequest::new("GET", "route53", &self.region, &request_uri);
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response.buffer().from_err().and_then(|response| {
Err(GetHealthCheckCountError::from_response(response))
}),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let mut result;
if response.body.is_empty() {
result = GetHealthCheckCountResponse::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 = peek_at_name(&mut stack)?;
result = GetHealthCheckCountResponseDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
#[allow(unused_variables, warnings)]
fn get_health_check_last_failure_reason(
&self,
input: GetHealthCheckLastFailureReasonRequest,
) -> RusotoFuture<GetHealthCheckLastFailureReasonResponse, GetHealthCheckLastFailureReasonError>
{
let request_uri = format!(
"/2013-04-01/healthcheck/{health_check_id}/lastfailurereason",
health_check_id = input.health_check_id
)
.replace("/hostedzone/hostedzone/", "/hostedzone/")
.replace("/change/change/", "/change/");
let mut request = SignedRequest::new("GET", "route53", &self.region, &request_uri);
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(GetHealthCheckLastFailureReasonError::from_response(
response,
))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let mut result;
if response.body.is_empty() {
result = GetHealthCheckLastFailureReasonResponse::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 = peek_at_name(&mut stack)?;
result = GetHealthCheckLastFailureReasonResponseDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
#[allow(unused_variables, warnings)]
fn get_health_check_status(
&self,
input: GetHealthCheckStatusRequest,
) -> RusotoFuture<GetHealthCheckStatusResponse, GetHealthCheckStatusError> {
let request_uri = format!(
"/2013-04-01/healthcheck/{health_check_id}/status",
health_check_id = input.health_check_id
)
.replace("/hostedzone/hostedzone/", "/hostedzone/")
.replace("/change/change/", "/change/");
let mut request = SignedRequest::new("GET", "route53", &self.region, &request_uri);
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response.buffer().from_err().and_then(|response| {
Err(GetHealthCheckStatusError::from_response(response))
}),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let mut result;
if response.body.is_empty() {
result = GetHealthCheckStatusResponse::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 = peek_at_name(&mut stack)?;
result = GetHealthCheckStatusResponseDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
#[allow(unused_variables, warnings)]
fn get_hosted_zone(
&self,
input: GetHostedZoneRequest,
) -> RusotoFuture<GetHostedZoneResponse, GetHostedZoneError> {
let request_uri = format!("/2013-04-01/hostedzone/{id}", id = input.id)
.replace("/hostedzone/hostedzone/", "/hostedzone/")
.replace("/change/change/", "/change/");
let mut request = SignedRequest::new("GET", "route53", &self.region, &request_uri);
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(GetHostedZoneError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let mut result;
if response.body.is_empty() {
result = GetHostedZoneResponse::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 = peek_at_name(&mut stack)?;
result = GetHostedZoneResponseDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
#[allow(unused_variables, warnings)]
fn get_hosted_zone_count(
&self,
input: GetHostedZoneCountRequest,
) -> RusotoFuture<GetHostedZoneCountResponse, GetHostedZoneCountError> {
let request_uri = "/2013-04-01/hostedzonecount";
let mut request = SignedRequest::new("GET", "route53", &self.region, &request_uri);
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(GetHostedZoneCountError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let mut result;
if response.body.is_empty() {
result = GetHostedZoneCountResponse::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 = peek_at_name(&mut stack)?;
result = GetHostedZoneCountResponseDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
#[allow(unused_variables, warnings)]
fn get_hosted_zone_limit(
&self,
input: GetHostedZoneLimitRequest,
) -> RusotoFuture<GetHostedZoneLimitResponse, GetHostedZoneLimitError> {
let request_uri = format!("/2013-04-01/hostedzonelimit/{id}/{type}", id = input.hosted_zone_id, type = input.type_).replace("/hostedzone/hostedzone/", "/hostedzone/").replace("/change/change/", "/change/");
let mut request = SignedRequest::new("GET", "route53", &self.region, &request_uri);
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(GetHostedZoneLimitError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let mut result;
if response.body.is_empty() {
result = GetHostedZoneLimitResponse::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 = peek_at_name(&mut stack)?;
result = GetHostedZoneLimitResponseDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
#[allow(unused_variables, warnings)]
fn get_query_logging_config(
&self,
input: GetQueryLoggingConfigRequest,
) -> RusotoFuture<GetQueryLoggingConfigResponse, GetQueryLoggingConfigError> {
let request_uri = format!("/2013-04-01/queryloggingconfig/{id}", id = input.id)
.replace("/hostedzone/hostedzone/", "/hostedzone/")
.replace("/change/change/", "/change/");
let mut request = SignedRequest::new("GET", "route53", &self.region, &request_uri);
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response.buffer().from_err().and_then(|response| {
Err(GetQueryLoggingConfigError::from_response(response))
}),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let mut result;
if response.body.is_empty() {
result = GetQueryLoggingConfigResponse::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 = peek_at_name(&mut stack)?;
result = GetQueryLoggingConfigResponseDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
#[allow(unused_variables, warnings)]
fn get_reusable_delegation_set(
&self,
input: GetReusableDelegationSetRequest,
) -> RusotoFuture<GetReusableDelegationSetResponse, GetReusableDelegationSetError> {
let request_uri = format!("/2013-04-01/delegationset/{id}", id = input.id)
.replace("/hostedzone/hostedzone/", "/hostedzone/")
.replace("/change/change/", "/change/");
let mut request = SignedRequest::new("GET", "route53", &self.region, &request_uri);
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(GetReusableDelegationSetError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let mut result;
if response.body.is_empty() {
result = GetReusableDelegationSetResponse::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 = peek_at_name(&mut stack)?;
result = GetReusableDelegationSetResponseDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
#[allow(unused_variables, warnings)]
fn get_reusable_delegation_set_limit(
&self,
input: GetReusableDelegationSetLimitRequest,
) -> RusotoFuture<GetReusableDelegationSetLimitResponse, GetReusableDelegationSetLimitError>
{
let request_uri = format!("/2013-04-01/reusabledelegationsetlimit/{id}/{type}", id = input.delegation_set_id, type = input.type_).replace("/hostedzone/hostedzone/", "/hostedzone/").replace("/change/change/", "/change/");
let mut request = SignedRequest::new("GET", "route53", &self.region, &request_uri);
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(GetReusableDelegationSetLimitError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let mut result;
if response.body.is_empty() {
result = GetReusableDelegationSetLimitResponse::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 = peek_at_name(&mut stack)?;
result = GetReusableDelegationSetLimitResponseDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
#[allow(unused_variables, warnings)]
fn get_traffic_policy(
&self,
input: GetTrafficPolicyRequest,
) -> RusotoFuture<GetTrafficPolicyResponse, GetTrafficPolicyError> {
let request_uri = format!(
"/2013-04-01/trafficpolicy/{id}/{version}",
id = input.id,
version = input.version
)
.replace("/hostedzone/hostedzone/", "/hostedzone/")
.replace("/change/change/", "/change/");
let mut request = SignedRequest::new("GET", "route53", &self.region, &request_uri);
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(GetTrafficPolicyError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let mut result;
if response.body.is_empty() {
result = GetTrafficPolicyResponse::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 = peek_at_name(&mut stack)?;
result = GetTrafficPolicyResponseDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
#[allow(unused_variables, warnings)]
fn get_traffic_policy_instance(
&self,
input: GetTrafficPolicyInstanceRequest,
) -> RusotoFuture<GetTrafficPolicyInstanceResponse, GetTrafficPolicyInstanceError> {
let request_uri = format!("/2013-04-01/trafficpolicyinstance/{id}", id = input.id)
.replace("/hostedzone/hostedzone/", "/hostedzone/")
.replace("/change/change/", "/change/");
let mut request = SignedRequest::new("GET", "route53", &self.region, &request_uri);
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(GetTrafficPolicyInstanceError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let mut result;
if response.body.is_empty() {
result = GetTrafficPolicyInstanceResponse::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 = peek_at_name(&mut stack)?;
result = GetTrafficPolicyInstanceResponseDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
#[allow(unused_variables, warnings)]
fn get_traffic_policy_instance_count(
&self,
input: GetTrafficPolicyInstanceCountRequest,
) -> RusotoFuture<GetTrafficPolicyInstanceCountResponse, GetTrafficPolicyInstanceCountError>
{
let request_uri = "/2013-04-01/trafficpolicyinstancecount";
let mut request = SignedRequest::new("GET", "route53", &self.region, &request_uri);
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(GetTrafficPolicyInstanceCountError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let mut result;
if response.body.is_empty() {
result = GetTrafficPolicyInstanceCountResponse::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 = peek_at_name(&mut stack)?;
result = GetTrafficPolicyInstanceCountResponseDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
#[allow(unused_variables, warnings)]
fn list_geo_locations(
&self,
input: ListGeoLocationsRequest,
) -> RusotoFuture<ListGeoLocationsResponse, ListGeoLocationsError> {
let request_uri = "/2013-04-01/geolocations";
let mut request = SignedRequest::new("GET", "route53", &self.region, &request_uri);
let mut params = Params::new();
if let Some(ref x) = input.max_items {
params.put("maxitems", x);
}
if let Some(ref x) = input.start_continent_code {
params.put("startcontinentcode", x);
}
if let Some(ref x) = input.start_country_code {
params.put("startcountrycode", x);
}
if let Some(ref x) = input.start_subdivision_code {
params.put("startsubdivisioncode", x);
}
request.set_params(params);
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(ListGeoLocationsError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let mut result;
if response.body.is_empty() {
result = ListGeoLocationsResponse::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 = peek_at_name(&mut stack)?;
result = ListGeoLocationsResponseDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
#[allow(unused_variables, warnings)]
fn list_health_checks(
&self,
input: ListHealthChecksRequest,
) -> RusotoFuture<ListHealthChecksResponse, ListHealthChecksError> {
let request_uri = "/2013-04-01/healthcheck";
let mut request = SignedRequest::new("GET", "route53", &self.region, &request_uri);
let mut params = Params::new();
if let Some(ref x) = input.marker {
params.put("marker", x);
}
if let Some(ref x) = input.max_items {
params.put("maxitems", x);
}
request.set_params(params);
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(ListHealthChecksError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let mut result;
if response.body.is_empty() {
result = ListHealthChecksResponse::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 = peek_at_name(&mut stack)?;
result = ListHealthChecksResponseDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
#[allow(unused_variables, warnings)]
fn list_hosted_zones(
&self,
input: ListHostedZonesRequest,
) -> RusotoFuture<ListHostedZonesResponse, ListHostedZonesError> {
let request_uri = "/2013-04-01/hostedzone";
let mut request = SignedRequest::new("GET", "route53", &self.region, &request_uri);
let mut params = Params::new();
if let Some(ref x) = input.delegation_set_id {
params.put("delegationsetid", x);
}
if let Some(ref x) = input.marker {
params.put("marker", x);
}
if let Some(ref x) = input.max_items {
params.put("maxitems", x);
}
request.set_params(params);
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(ListHostedZonesError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let mut result;
if response.body.is_empty() {
result = ListHostedZonesResponse::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 = peek_at_name(&mut stack)?;
result = ListHostedZonesResponseDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
#[allow(unused_variables, warnings)]
fn list_hosted_zones_by_name(
&self,
input: ListHostedZonesByNameRequest,
) -> RusotoFuture<ListHostedZonesByNameResponse, ListHostedZonesByNameError> {
let request_uri = "/2013-04-01/hostedzonesbyname";
let mut request = SignedRequest::new("GET", "route53", &self.region, &request_uri);
let mut params = Params::new();
if let Some(ref x) = input.dns_name {
params.put("dnsname", x);
}
if let Some(ref x) = input.hosted_zone_id {
params.put("hostedzoneid", x);
}
if let Some(ref x) = input.max_items {
params.put("maxitems", x);
}
request.set_params(params);
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response.buffer().from_err().and_then(|response| {
Err(ListHostedZonesByNameError::from_response(response))
}),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let mut result;
if response.body.is_empty() {
result = ListHostedZonesByNameResponse::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 = peek_at_name(&mut stack)?;
result = ListHostedZonesByNameResponseDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
#[allow(unused_variables, warnings)]
fn list_query_logging_configs(
&self,
input: ListQueryLoggingConfigsRequest,
) -> RusotoFuture<ListQueryLoggingConfigsResponse, ListQueryLoggingConfigsError> {
let request_uri = "/2013-04-01/queryloggingconfig";
let mut request = SignedRequest::new("GET", "route53", &self.region, &request_uri);
let mut params = Params::new();
if let Some(ref x) = input.hosted_zone_id {
params.put("hostedzoneid", x);
}
if let Some(ref x) = input.max_results {
params.put("maxresults", x);
}
if let Some(ref x) = input.next_token {
params.put("nexttoken", x);
}
request.set_params(params);
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(ListQueryLoggingConfigsError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let mut result;
if response.body.is_empty() {
result = ListQueryLoggingConfigsResponse::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 = peek_at_name(&mut stack)?;
result = ListQueryLoggingConfigsResponseDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
#[allow(unused_variables, warnings)]
fn list_resource_record_sets(
&self,
input: ListResourceRecordSetsRequest,
) -> RusotoFuture<ListResourceRecordSetsResponse, ListResourceRecordSetsError> {
let request_uri = format!(
"/2013-04-01/hostedzone/{id}/rrset",
id = input.hosted_zone_id
)
.replace("/hostedzone/hostedzone/", "/hostedzone/")
.replace("/change/change/", "/change/");
let mut request = SignedRequest::new("GET", "route53", &self.region, &request_uri);
let mut params = Params::new();
if let Some(ref x) = input.max_items {
params.put("maxitems", x);
}
if let Some(ref x) = input.start_record_identifier {
params.put("identifier", x);
}
if let Some(ref x) = input.start_record_name {
params.put("name", x);
}
if let Some(ref x) = input.start_record_type {
params.put("type", x);
}
request.set_params(params);
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(ListResourceRecordSetsError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let mut result;
if response.body.is_empty() {
result = ListResourceRecordSetsResponse::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 = peek_at_name(&mut stack)?;
result = ListResourceRecordSetsResponseDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
#[allow(unused_variables, warnings)]
fn list_reusable_delegation_sets(
&self,
input: ListReusableDelegationSetsRequest,
) -> RusotoFuture<ListReusableDelegationSetsResponse, ListReusableDelegationSetsError> {
let request_uri = "/2013-04-01/delegationset";
let mut request = SignedRequest::new("GET", "route53", &self.region, &request_uri);
let mut params = Params::new();
if let Some(ref x) = input.marker {
params.put("marker", x);
}
if let Some(ref x) = input.max_items {
params.put("maxitems", x);
}
request.set_params(params);
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(ListReusableDelegationSetsError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let mut result;
if response.body.is_empty() {
result = ListReusableDelegationSetsResponse::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 = peek_at_name(&mut stack)?;
result = ListReusableDelegationSetsResponseDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
#[allow(unused_variables, warnings)]
fn list_tags_for_resource(
&self,
input: ListTagsForResourceRequest,
) -> RusotoFuture<ListTagsForResourceResponse, ListTagsForResourceError> {
let request_uri = format!(
"/2013-04-01/tags/{resource_type}/{resource_id}",
resource_id = input.resource_id,
resource_type = input.resource_type
)
.replace("/hostedzone/hostedzone/", "/hostedzone/")
.replace("/change/change/", "/change/");
let mut request = SignedRequest::new("GET", "route53", &self.region, &request_uri);
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response.buffer().from_err().and_then(|response| {
Err(ListTagsForResourceError::from_response(response))
}),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let mut result;
if response.body.is_empty() {
result = ListTagsForResourceResponse::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 = peek_at_name(&mut stack)?;
result = ListTagsForResourceResponseDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
#[allow(unused_variables, warnings)]
fn list_tags_for_resources(
&self,
input: ListTagsForResourcesRequest,
) -> RusotoFuture<ListTagsForResourcesResponse, ListTagsForResourcesError> {
let request_uri = format!(
"/2013-04-01/tags/{resource_type}",
resource_type = input.resource_type
)
.replace("/hostedzone/hostedzone/", "/hostedzone/")
.replace("/change/change/", "/change/");
let mut request = SignedRequest::new("POST", "route53", &self.region, &request_uri);
let mut writer = EventWriter::new(Vec::new());
ListTagsForResourcesRequestSerializer::serialize(
&mut writer,
"ListTagsForResourcesRequest",
&input,
"https://route53.amazonaws.com/doc/2013-04-01/",
);
request.set_payload(Some(writer.into_inner()));
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response.buffer().from_err().and_then(|response| {
Err(ListTagsForResourcesError::from_response(response))
}),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let mut result;
if response.body.is_empty() {
result = ListTagsForResourcesResponse::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 = peek_at_name(&mut stack)?;
result = ListTagsForResourcesResponseDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
#[allow(unused_variables, warnings)]
fn list_traffic_policies(
&self,
input: ListTrafficPoliciesRequest,
) -> RusotoFuture<ListTrafficPoliciesResponse, ListTrafficPoliciesError> {
let request_uri = "/2013-04-01/trafficpolicies";
let mut request = SignedRequest::new("GET", "route53", &self.region, &request_uri);
let mut params = Params::new();
if let Some(ref x) = input.max_items {
params.put("maxitems", x);
}
if let Some(ref x) = input.traffic_policy_id_marker {
params.put("trafficpolicyid", x);
}
request.set_params(params);
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response.buffer().from_err().and_then(|response| {
Err(ListTrafficPoliciesError::from_response(response))
}),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let mut result;
if response.body.is_empty() {
result = ListTrafficPoliciesResponse::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 = peek_at_name(&mut stack)?;
result = ListTrafficPoliciesResponseDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
#[allow(unused_variables, warnings)]
fn list_traffic_policy_instances(
&self,
input: ListTrafficPolicyInstancesRequest,
) -> RusotoFuture<ListTrafficPolicyInstancesResponse, ListTrafficPolicyInstancesError> {
let request_uri = "/2013-04-01/trafficpolicyinstances";
let mut request = SignedRequest::new("GET", "route53", &self.region, &request_uri);
let mut params = Params::new();
if let Some(ref x) = input.hosted_zone_id_marker {
params.put("hostedzoneid", x);
}
if let Some(ref x) = input.max_items {
params.put("maxitems", x);
}
if let Some(ref x) = input.traffic_policy_instance_name_marker {
params.put("trafficpolicyinstancename", x);
}
if let Some(ref x) = input.traffic_policy_instance_type_marker {
params.put("trafficpolicyinstancetype", x);
}
request.set_params(params);
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(ListTrafficPolicyInstancesError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let mut result;
if response.body.is_empty() {
result = ListTrafficPolicyInstancesResponse::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 = peek_at_name(&mut stack)?;
result = ListTrafficPolicyInstancesResponseDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
#[allow(unused_variables, warnings)]
fn list_traffic_policy_instances_by_hosted_zone(
&self,
input: ListTrafficPolicyInstancesByHostedZoneRequest,
) -> RusotoFuture<
ListTrafficPolicyInstancesByHostedZoneResponse,
ListTrafficPolicyInstancesByHostedZoneError,
> {
let request_uri = "/2013-04-01/trafficpolicyinstances/hostedzone";
let mut request = SignedRequest::new("GET", "route53", &self.region, &request_uri);
let mut params = Params::new();
params.put("id", &input.hosted_zone_id);
if let Some(ref x) = input.max_items {
params.put("maxitems", x);
}
if let Some(ref x) = input.traffic_policy_instance_name_marker {
params.put("trafficpolicyinstancename", x);
}
if let Some(ref x) = input.traffic_policy_instance_type_marker {
params.put("trafficpolicyinstancetype", x);
}
request.set_params(params);
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(ListTrafficPolicyInstancesByHostedZoneError::from_response(
response,
))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let mut result;
if response.body.is_empty() {
result = ListTrafficPolicyInstancesByHostedZoneResponse::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 = peek_at_name(&mut stack)?;
result =
ListTrafficPolicyInstancesByHostedZoneResponseDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
#[allow(unused_variables, warnings)]
fn list_traffic_policy_instances_by_policy(
&self,
input: ListTrafficPolicyInstancesByPolicyRequest,
) -> RusotoFuture<
ListTrafficPolicyInstancesByPolicyResponse,
ListTrafficPolicyInstancesByPolicyError,
> {
let request_uri = "/2013-04-01/trafficpolicyinstances/trafficpolicy";
let mut request = SignedRequest::new("GET", "route53", &self.region, &request_uri);
let mut params = Params::new();
if let Some(ref x) = input.hosted_zone_id_marker {
params.put("hostedzoneid", x);
}
if let Some(ref x) = input.max_items {
params.put("maxitems", x);
}
params.put("id", &input.traffic_policy_id);
if let Some(ref x) = input.traffic_policy_instance_name_marker {
params.put("trafficpolicyinstancename", x);
}
if let Some(ref x) = input.traffic_policy_instance_type_marker {
params.put("trafficpolicyinstancetype", x);
}
params.put("version", &input.traffic_policy_version);
request.set_params(params);
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(ListTrafficPolicyInstancesByPolicyError::from_response(
response,
))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let mut result;
if response.body.is_empty() {
result = ListTrafficPolicyInstancesByPolicyResponse::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 = peek_at_name(&mut stack)?;
result = ListTrafficPolicyInstancesByPolicyResponseDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
#[allow(unused_variables, warnings)]
fn list_traffic_policy_versions(
&self,
input: ListTrafficPolicyVersionsRequest,
) -> RusotoFuture<ListTrafficPolicyVersionsResponse, ListTrafficPolicyVersionsError> {
let request_uri = format!("/2013-04-01/trafficpolicies/{id}/versions", id = input.id)
.replace("/hostedzone/hostedzone/", "/hostedzone/")
.replace("/change/change/", "/change/");
let mut request = SignedRequest::new("GET", "route53", &self.region, &request_uri);
let mut params = Params::new();
if let Some(ref x) = input.max_items {
params.put("maxitems", x);
}
if let Some(ref x) = input.traffic_policy_version_marker {
params.put("trafficpolicyversion", x);
}
request.set_params(params);
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(ListTrafficPolicyVersionsError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let mut result;
if response.body.is_empty() {
result = ListTrafficPolicyVersionsResponse::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 = peek_at_name(&mut stack)?;
result = ListTrafficPolicyVersionsResponseDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
#[allow(unused_variables, warnings)]
fn list_vpc_association_authorizations(
&self,
input: ListVPCAssociationAuthorizationsRequest,
) -> RusotoFuture<ListVPCAssociationAuthorizationsResponse, ListVPCAssociationAuthorizationsError>
{
let request_uri = format!(
"/2013-04-01/hostedzone/{id}/authorizevpcassociation",
id = input.hosted_zone_id
)
.replace("/hostedzone/hostedzone/", "/hostedzone/")
.replace("/change/change/", "/change/");
let mut request = SignedRequest::new("GET", "route53", &self.region, &request_uri);
let mut params = Params::new();
if let Some(ref x) = input.max_results {
params.put("maxresults", x);
}
if let Some(ref x) = input.next_token {
params.put("nexttoken", x);
}
request.set_params(params);
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(ListVPCAssociationAuthorizationsError::from_response(
response,
))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let mut result;
if response.body.is_empty() {
result = ListVPCAssociationAuthorizationsResponse::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 = peek_at_name(&mut stack)?;
result = ListVPCAssociationAuthorizationsResponseDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
#[allow(unused_variables, warnings)]
fn test_dns_answer(
&self,
input: TestDNSAnswerRequest,
) -> RusotoFuture<TestDNSAnswerResponse, TestDNSAnswerError> {
let request_uri = "/2013-04-01/testdnsanswer";
let mut request = SignedRequest::new("GET", "route53", &self.region, &request_uri);
let mut params = Params::new();
if let Some(ref x) = input.edns0_client_subnet_ip {
params.put("edns0clientsubnetip", x);
}
if let Some(ref x) = input.edns0_client_subnet_mask {
params.put("edns0clientsubnetmask", x);
}
params.put("hostedzoneid", &input.hosted_zone_id);
params.put("recordname", &input.record_name);
params.put("recordtype", &input.record_type);
if let Some(ref x) = input.resolver_ip {
params.put("resolverip", x);
}
request.set_params(params);
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(TestDNSAnswerError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let mut result;
if response.body.is_empty() {
result = TestDNSAnswerResponse::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 = peek_at_name(&mut stack)?;
result = TestDNSAnswerResponseDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
#[allow(unused_variables, warnings)]
fn update_health_check(
&self,
input: UpdateHealthCheckRequest,
) -> RusotoFuture<UpdateHealthCheckResponse, UpdateHealthCheckError> {
let request_uri = format!(
"/2013-04-01/healthcheck/{health_check_id}",
health_check_id = input.health_check_id
)
.replace("/hostedzone/hostedzone/", "/hostedzone/")
.replace("/change/change/", "/change/");
let mut request = SignedRequest::new("POST", "route53", &self.region, &request_uri);
let mut writer = EventWriter::new(Vec::new());
UpdateHealthCheckRequestSerializer::serialize(
&mut writer,
"UpdateHealthCheckRequest",
&input,
"https://route53.amazonaws.com/doc/2013-04-01/",
);
request.set_payload(Some(writer.into_inner()));
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(UpdateHealthCheckError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let mut result;
if response.body.is_empty() {
result = UpdateHealthCheckResponse::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 = peek_at_name(&mut stack)?;
result = UpdateHealthCheckResponseDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
#[allow(unused_variables, warnings)]
fn update_hosted_zone_comment(
&self,
input: UpdateHostedZoneCommentRequest,
) -> RusotoFuture<UpdateHostedZoneCommentResponse, UpdateHostedZoneCommentError> {
let request_uri = format!("/2013-04-01/hostedzone/{id}", id = input.id)
.replace("/hostedzone/hostedzone/", "/hostedzone/")
.replace("/change/change/", "/change/");
let mut request = SignedRequest::new("POST", "route53", &self.region, &request_uri);
let mut writer = EventWriter::new(Vec::new());
UpdateHostedZoneCommentRequestSerializer::serialize(
&mut writer,
"UpdateHostedZoneCommentRequest",
&input,
"https://route53.amazonaws.com/doc/2013-04-01/",
);
request.set_payload(Some(writer.into_inner()));
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(UpdateHostedZoneCommentError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let mut result;
if response.body.is_empty() {
result = UpdateHostedZoneCommentResponse::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 = peek_at_name(&mut stack)?;
result = UpdateHostedZoneCommentResponseDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
#[allow(unused_variables, warnings)]
fn update_traffic_policy_comment(
&self,
input: UpdateTrafficPolicyCommentRequest,
) -> RusotoFuture<UpdateTrafficPolicyCommentResponse, UpdateTrafficPolicyCommentError> {
let request_uri = format!(
"/2013-04-01/trafficpolicy/{id}/{version}",
id = input.id,
version = input.version
)
.replace("/hostedzone/hostedzone/", "/hostedzone/")
.replace("/change/change/", "/change/");
let mut request = SignedRequest::new("POST", "route53", &self.region, &request_uri);
let mut writer = EventWriter::new(Vec::new());
UpdateTrafficPolicyCommentRequestSerializer::serialize(
&mut writer,
"UpdateTrafficPolicyCommentRequest",
&input,
"https://route53.amazonaws.com/doc/2013-04-01/",
);
request.set_payload(Some(writer.into_inner()));
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(UpdateTrafficPolicyCommentError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let mut result;
if response.body.is_empty() {
result = UpdateTrafficPolicyCommentResponse::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 = peek_at_name(&mut stack)?;
result = UpdateTrafficPolicyCommentResponseDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
#[allow(unused_variables, warnings)]
fn update_traffic_policy_instance(
&self,
input: UpdateTrafficPolicyInstanceRequest,
) -> RusotoFuture<UpdateTrafficPolicyInstanceResponse, UpdateTrafficPolicyInstanceError> {
let request_uri = format!("/2013-04-01/trafficpolicyinstance/{id}", id = input.id)
.replace("/hostedzone/hostedzone/", "/hostedzone/")
.replace("/change/change/", "/change/");
let mut request = SignedRequest::new("POST", "route53", &self.region, &request_uri);
let mut writer = EventWriter::new(Vec::new());
UpdateTrafficPolicyInstanceRequestSerializer::serialize(
&mut writer,
"UpdateTrafficPolicyInstanceRequest",
&input,
"https://route53.amazonaws.com/doc/2013-04-01/",
);
request.set_payload(Some(writer.into_inner()));
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(UpdateTrafficPolicyInstanceError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let mut result;
if response.body.is_empty() {
result = UpdateTrafficPolicyInstanceResponse::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 = peek_at_name(&mut stack)?;
result = UpdateTrafficPolicyInstanceResponseDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
}
#[cfg(test)]
mod protocol_tests {
extern crate rusoto_mock;
use self::rusoto_mock::*;
use super::*;
use rusoto_core::Region as rusoto_region;
#[test]
fn test_parse_error_route_53_get_hosted_zone() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/error",
"route53-get-hosted-zone.xml",
);
let mock = MockRequestDispatcher::with_status(400).with_body(&mock_response);
let client = Route53Client::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = GetHostedZoneRequest::default();
let result = client.get_hosted_zone(request).sync();
assert!(!result.is_ok(), "parse error: {:?}", result);
}
}