use std::error::Error;
use std::fmt;
use std::io;
#[allow(warnings)]
use futures::future;
use futures::Future;
use rusoto_core::region;
use rusoto_core::request::{BufferedHttpResponse, DispatchSignedRequest};
use rusoto_core::{Client, RusotoFuture};
use rusoto_core::credential::{CredentialsError, ProvideAwsCredentials};
use rusoto_core::request::HttpDispatchError;
use rusoto_core::param::{Params, ServiceParams};
use rusoto_core::signature::SignedRequest;
use rusoto_core::xmlerror::*;
use rusoto_core::xmlutil::{
characters, end_element, find_start_element, peek_at_name, skip_tree, start_element,
};
use rusoto_core::xmlutil::{Next, Peek, XmlParseError, XmlResponse};
use serde_urlencoded;
use std::str::FromStr;
use xml::reader::ParserConfig;
use xml::reader::XmlEvent;
use xml::EventReader;
enum DeserializerNext {
Close,
Skip,
Element(String),
}
struct ActivitiesDeserializer;
impl ActivitiesDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<Activity>, 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(ActivityDeserializer::deserialize("member", 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 ActivitiesType {
pub activities: Vec<Activity>,
pub next_token: Option<String>,
}
struct ActivitiesTypeDeserializer;
impl ActivitiesTypeDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ActivitiesType, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = ActivitiesType::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[..] {
"Activities" => {
obj.activities
.extend(ActivitiesDeserializer::deserialize("Activities", stack)?);
}
"NextToken" => {
obj.next_token =
Some(XmlStringDeserializer::deserialize("NextToken", 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 Activity {
pub activity_id: String,
pub auto_scaling_group_name: String,
pub cause: String,
pub description: Option<String>,
pub details: Option<String>,
pub end_time: Option<String>,
pub progress: Option<i64>,
pub start_time: String,
pub status_code: String,
pub status_message: Option<String>,
}
struct ActivityDeserializer;
impl ActivityDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Activity, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = Activity::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[..] {
"ActivityId" => {
obj.activity_id = XmlStringDeserializer::deserialize("ActivityId", stack)?;
}
"AutoScalingGroupName" => {
obj.auto_scaling_group_name = XmlStringMaxLen255Deserializer::deserialize(
"AutoScalingGroupName",
stack,
)?;
}
"Cause" => {
obj.cause = XmlStringMaxLen1023Deserializer::deserialize("Cause", stack)?;
}
"Description" => {
obj.description =
Some(XmlStringDeserializer::deserialize("Description", stack)?);
}
"Details" => {
obj.details = Some(XmlStringDeserializer::deserialize("Details", stack)?);
}
"EndTime" => {
obj.end_time =
Some(TimestampTypeDeserializer::deserialize("EndTime", stack)?);
}
"Progress" => {
obj.progress = Some(ProgressDeserializer::deserialize("Progress", stack)?);
}
"StartTime" => {
obj.start_time =
TimestampTypeDeserializer::deserialize("StartTime", stack)?;
}
"StatusCode" => {
obj.status_code = ScalingActivityStatusCodeDeserializer::deserialize(
"StatusCode",
stack,
)?;
}
"StatusMessage" => {
obj.status_message = Some(XmlStringMaxLen255Deserializer::deserialize(
"StatusMessage",
stack,
)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct ActivityIdsSerializer;
impl ActivityIdsSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.member.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ActivityType {
pub activity: Option<Activity>,
}
struct ActivityTypeDeserializer;
impl ActivityTypeDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ActivityType, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = ActivityType::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[..] {
"Activity" => {
obj.activity = Some(ActivityDeserializer::deserialize("Activity", 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 AdjustmentType {
pub adjustment_type: Option<String>,
}
struct AdjustmentTypeDeserializer;
impl AdjustmentTypeDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<AdjustmentType, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = AdjustmentType::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[..] {
"AdjustmentType" => {
obj.adjustment_type = Some(XmlStringMaxLen255Deserializer::deserialize(
"AdjustmentType",
stack,
)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct AdjustmentTypesDeserializer;
impl AdjustmentTypesDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<AdjustmentType>, 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(AdjustmentTypeDeserializer::deserialize("member", 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 Alarm {
pub alarm_arn: Option<String>,
pub alarm_name: Option<String>,
}
struct AlarmDeserializer;
impl AlarmDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Alarm, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = Alarm::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[..] {
"AlarmARN" => {
obj.alarm_arn =
Some(ResourceNameDeserializer::deserialize("AlarmARN", stack)?);
}
"AlarmName" => {
obj.alarm_name = Some(XmlStringMaxLen255Deserializer::deserialize(
"AlarmName",
stack,
)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct AlarmsDeserializer;
impl AlarmsDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<Alarm>, 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(AlarmDeserializer::deserialize("member", stack)?);
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
end_element(tag_name, stack)?;
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
struct AsciiStringMaxLen255Deserializer;
impl AsciiStringMaxLen255Deserializer {
#[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 AssociatePublicIpAddressDeserializer;
impl AssociatePublicIpAddressDeserializer {
#[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)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct AttachInstancesQuery {
pub auto_scaling_group_name: String,
pub instance_ids: Option<Vec<String>>,
}
struct AttachInstancesQuerySerializer;
impl AttachInstancesQuerySerializer {
fn serialize(params: &mut Params, name: &str, obj: &AttachInstancesQuery) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "AutoScalingGroupName"),
&obj.auto_scaling_group_name,
);
if let Some(ref field_value) = obj.instance_ids {
InstanceIdsSerializer::serialize(
params,
&format!("{}{}", prefix, "InstanceIds"),
field_value,
);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct AttachLoadBalancerTargetGroupsResultType {}
struct AttachLoadBalancerTargetGroupsResultTypeDeserializer;
impl AttachLoadBalancerTargetGroupsResultTypeDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<AttachLoadBalancerTargetGroupsResultType, XmlParseError> {
start_element(tag_name, stack)?;
let obj = AttachLoadBalancerTargetGroupsResultType::default();
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct AttachLoadBalancerTargetGroupsType {
pub auto_scaling_group_name: String,
pub target_group_ar_ns: Vec<String>,
}
struct AttachLoadBalancerTargetGroupsTypeSerializer;
impl AttachLoadBalancerTargetGroupsTypeSerializer {
fn serialize(params: &mut Params, name: &str, obj: &AttachLoadBalancerTargetGroupsType) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "AutoScalingGroupName"),
&obj.auto_scaling_group_name,
);
TargetGroupARNsSerializer::serialize(
params,
&format!("{}{}", prefix, "TargetGroupARNs"),
&obj.target_group_ar_ns,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct AttachLoadBalancersResultType {}
struct AttachLoadBalancersResultTypeDeserializer;
impl AttachLoadBalancersResultTypeDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<AttachLoadBalancersResultType, XmlParseError> {
start_element(tag_name, stack)?;
let obj = AttachLoadBalancersResultType::default();
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct AttachLoadBalancersType {
pub auto_scaling_group_name: String,
pub load_balancer_names: Vec<String>,
}
struct AttachLoadBalancersTypeSerializer;
impl AttachLoadBalancersTypeSerializer {
fn serialize(params: &mut Params, name: &str, obj: &AttachLoadBalancersType) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "AutoScalingGroupName"),
&obj.auto_scaling_group_name,
);
LoadBalancerNamesSerializer::serialize(
params,
&format!("{}{}", prefix, "LoadBalancerNames"),
&obj.load_balancer_names,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct AutoScalingGroup {
pub auto_scaling_group_arn: Option<String>,
pub auto_scaling_group_name: String,
pub availability_zones: Vec<String>,
pub created_time: String,
pub default_cooldown: i64,
pub desired_capacity: i64,
pub enabled_metrics: Option<Vec<EnabledMetric>>,
pub health_check_grace_period: Option<i64>,
pub health_check_type: String,
pub instances: Option<Vec<Instance>>,
pub launch_configuration_name: Option<String>,
pub launch_template: Option<LaunchTemplateSpecification>,
pub load_balancer_names: Option<Vec<String>>,
pub max_size: i64,
pub min_size: i64,
pub mixed_instances_policy: Option<MixedInstancesPolicy>,
pub new_instances_protected_from_scale_in: Option<bool>,
pub placement_group: Option<String>,
pub service_linked_role_arn: Option<String>,
pub status: Option<String>,
pub suspended_processes: Option<Vec<SuspendedProcess>>,
pub tags: Option<Vec<TagDescription>>,
pub target_group_ar_ns: Option<Vec<String>>,
pub termination_policies: Option<Vec<String>>,
pub vpc_zone_identifier: Option<String>,
}
struct AutoScalingGroupDeserializer;
impl AutoScalingGroupDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<AutoScalingGroup, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = AutoScalingGroup::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[..] {
"AutoScalingGroupARN" => {
obj.auto_scaling_group_arn = Some(ResourceNameDeserializer::deserialize(
"AutoScalingGroupARN",
stack,
)?);
}
"AutoScalingGroupName" => {
obj.auto_scaling_group_name = XmlStringMaxLen255Deserializer::deserialize(
"AutoScalingGroupName",
stack,
)?;
}
"AvailabilityZones" => {
obj.availability_zones
.extend(AvailabilityZonesDeserializer::deserialize(
"AvailabilityZones",
stack,
)?);
}
"CreatedTime" => {
obj.created_time =
TimestampTypeDeserializer::deserialize("CreatedTime", stack)?;
}
"DefaultCooldown" => {
obj.default_cooldown =
CooldownDeserializer::deserialize("DefaultCooldown", stack)?;
}
"DesiredCapacity" => {
obj.desired_capacity =
AutoScalingGroupDesiredCapacityDeserializer::deserialize(
"DesiredCapacity",
stack,
)?;
}
"EnabledMetrics" => {
obj.enabled_metrics = match obj.enabled_metrics {
Some(ref mut existing) => {
existing.extend(EnabledMetricsDeserializer::deserialize(
"EnabledMetrics",
stack,
)?);
Some(existing.to_vec())
}
None => Some(EnabledMetricsDeserializer::deserialize(
"EnabledMetrics",
stack,
)?),
};
}
"HealthCheckGracePeriod" => {
obj.health_check_grace_period =
Some(HealthCheckGracePeriodDeserializer::deserialize(
"HealthCheckGracePeriod",
stack,
)?);
}
"HealthCheckType" => {
obj.health_check_type =
XmlStringMaxLen32Deserializer::deserialize("HealthCheckType", stack)?;
}
"Instances" => {
obj.instances = match obj.instances {
Some(ref mut existing) => {
existing.extend(InstancesDeserializer::deserialize(
"Instances",
stack,
)?);
Some(existing.to_vec())
}
None => Some(InstancesDeserializer::deserialize("Instances", stack)?),
};
}
"LaunchConfigurationName" => {
obj.launch_configuration_name =
Some(XmlStringMaxLen255Deserializer::deserialize(
"LaunchConfigurationName",
stack,
)?);
}
"LaunchTemplate" => {
obj.launch_template =
Some(LaunchTemplateSpecificationDeserializer::deserialize(
"LaunchTemplate",
stack,
)?);
}
"LoadBalancerNames" => {
obj.load_balancer_names = match obj.load_balancer_names {
Some(ref mut existing) => {
existing.extend(LoadBalancerNamesDeserializer::deserialize(
"LoadBalancerNames",
stack,
)?);
Some(existing.to_vec())
}
None => Some(LoadBalancerNamesDeserializer::deserialize(
"LoadBalancerNames",
stack,
)?),
};
}
"MaxSize" => {
obj.max_size =
AutoScalingGroupMaxSizeDeserializer::deserialize("MaxSize", stack)?;
}
"MinSize" => {
obj.min_size =
AutoScalingGroupMinSizeDeserializer::deserialize("MinSize", stack)?;
}
"MixedInstancesPolicy" => {
obj.mixed_instances_policy =
Some(MixedInstancesPolicyDeserializer::deserialize(
"MixedInstancesPolicy",
stack,
)?);
}
"NewInstancesProtectedFromScaleIn" => {
obj.new_instances_protected_from_scale_in =
Some(InstanceProtectedDeserializer::deserialize(
"NewInstancesProtectedFromScaleIn",
stack,
)?);
}
"PlacementGroup" => {
obj.placement_group = Some(XmlStringMaxLen255Deserializer::deserialize(
"PlacementGroup",
stack,
)?);
}
"ServiceLinkedRoleARN" => {
obj.service_linked_role_arn = Some(ResourceNameDeserializer::deserialize(
"ServiceLinkedRoleARN",
stack,
)?);
}
"Status" => {
obj.status = Some(XmlStringMaxLen255Deserializer::deserialize(
"Status", stack,
)?);
}
"SuspendedProcesses" => {
obj.suspended_processes = match obj.suspended_processes {
Some(ref mut existing) => {
existing.extend(SuspendedProcessesDeserializer::deserialize(
"SuspendedProcesses",
stack,
)?);
Some(existing.to_vec())
}
None => Some(SuspendedProcessesDeserializer::deserialize(
"SuspendedProcesses",
stack,
)?),
};
}
"Tags" => {
obj.tags = match obj.tags {
Some(ref mut existing) => {
existing.extend(TagDescriptionListDeserializer::deserialize(
"Tags", stack,
)?);
Some(existing.to_vec())
}
None => {
Some(TagDescriptionListDeserializer::deserialize("Tags", stack)?)
}
};
}
"TargetGroupARNs" => {
obj.target_group_ar_ns = match obj.target_group_ar_ns {
Some(ref mut existing) => {
existing.extend(TargetGroupARNsDeserializer::deserialize(
"TargetGroupARNs",
stack,
)?);
Some(existing.to_vec())
}
None => Some(TargetGroupARNsDeserializer::deserialize(
"TargetGroupARNs",
stack,
)?),
};
}
"TerminationPolicies" => {
obj.termination_policies = match obj.termination_policies {
Some(ref mut existing) => {
existing.extend(TerminationPoliciesDeserializer::deserialize(
"TerminationPolicies",
stack,
)?);
Some(existing.to_vec())
}
None => Some(TerminationPoliciesDeserializer::deserialize(
"TerminationPolicies",
stack,
)?),
};
}
"VPCZoneIdentifier" => {
obj.vpc_zone_identifier =
Some(XmlStringMaxLen2047Deserializer::deserialize(
"VPCZoneIdentifier",
stack,
)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct AutoScalingGroupDesiredCapacityDeserializer;
impl AutoScalingGroupDesiredCapacityDeserializer {
#[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 AutoScalingGroupMaxSizeDeserializer;
impl AutoScalingGroupMaxSizeDeserializer {
#[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 AutoScalingGroupMinSizeDeserializer;
impl AutoScalingGroupMinSizeDeserializer {
#[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 AutoScalingGroupNamesSerializer;
impl AutoScalingGroupNamesSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.member.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct AutoScalingGroupNamesType {
pub auto_scaling_group_names: Option<Vec<String>>,
pub max_records: Option<i64>,
pub next_token: Option<String>,
}
struct AutoScalingGroupNamesTypeSerializer;
impl AutoScalingGroupNamesTypeSerializer {
fn serialize(params: &mut Params, name: &str, obj: &AutoScalingGroupNamesType) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.auto_scaling_group_names {
AutoScalingGroupNamesSerializer::serialize(
params,
&format!("{}{}", prefix, "AutoScalingGroupNames"),
field_value,
);
}
if let Some(ref field_value) = obj.max_records {
params.put(
&format!("{}{}", prefix, "MaxRecords"),
&field_value.to_string(),
);
}
if let Some(ref field_value) = obj.next_token {
params.put(&format!("{}{}", prefix, "NextToken"), &field_value);
}
}
}
struct AutoScalingGroupsDeserializer;
impl AutoScalingGroupsDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<AutoScalingGroup>, 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(AutoScalingGroupDeserializer::deserialize("member", 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 AutoScalingGroupsType {
pub auto_scaling_groups: Vec<AutoScalingGroup>,
pub next_token: Option<String>,
}
struct AutoScalingGroupsTypeDeserializer;
impl AutoScalingGroupsTypeDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<AutoScalingGroupsType, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = AutoScalingGroupsType::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[..] {
"AutoScalingGroups" => {
obj.auto_scaling_groups
.extend(AutoScalingGroupsDeserializer::deserialize(
"AutoScalingGroups",
stack,
)?);
}
"NextToken" => {
obj.next_token =
Some(XmlStringDeserializer::deserialize("NextToken", 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 AutoScalingInstanceDetails {
pub auto_scaling_group_name: String,
pub availability_zone: String,
pub health_status: String,
pub instance_id: String,
pub launch_configuration_name: Option<String>,
pub launch_template: Option<LaunchTemplateSpecification>,
pub lifecycle_state: String,
pub protected_from_scale_in: bool,
}
struct AutoScalingInstanceDetailsDeserializer;
impl AutoScalingInstanceDetailsDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<AutoScalingInstanceDetails, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = AutoScalingInstanceDetails::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[..] {
"AutoScalingGroupName" => {
obj.auto_scaling_group_name = XmlStringMaxLen255Deserializer::deserialize(
"AutoScalingGroupName",
stack,
)?;
}
"AvailabilityZone" => {
obj.availability_zone =
XmlStringMaxLen255Deserializer::deserialize("AvailabilityZone", stack)?;
}
"HealthStatus" => {
obj.health_status =
XmlStringMaxLen32Deserializer::deserialize("HealthStatus", stack)?;
}
"InstanceId" => {
obj.instance_id =
XmlStringMaxLen19Deserializer::deserialize("InstanceId", stack)?;
}
"LaunchConfigurationName" => {
obj.launch_configuration_name =
Some(XmlStringMaxLen255Deserializer::deserialize(
"LaunchConfigurationName",
stack,
)?);
}
"LaunchTemplate" => {
obj.launch_template =
Some(LaunchTemplateSpecificationDeserializer::deserialize(
"LaunchTemplate",
stack,
)?);
}
"LifecycleState" => {
obj.lifecycle_state =
XmlStringMaxLen32Deserializer::deserialize("LifecycleState", stack)?;
}
"ProtectedFromScaleIn" => {
obj.protected_from_scale_in = InstanceProtectedDeserializer::deserialize(
"ProtectedFromScaleIn",
stack,
)?;
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct AutoScalingInstancesDeserializer;
impl AutoScalingInstancesDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<AutoScalingInstanceDetails>, 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(AutoScalingInstanceDetailsDeserializer::deserialize(
"member", 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 AutoScalingInstancesType {
pub auto_scaling_instances: Option<Vec<AutoScalingInstanceDetails>>,
pub next_token: Option<String>,
}
struct AutoScalingInstancesTypeDeserializer;
impl AutoScalingInstancesTypeDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<AutoScalingInstancesType, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = AutoScalingInstancesType::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[..] {
"AutoScalingInstances" => {
obj.auto_scaling_instances = match obj.auto_scaling_instances {
Some(ref mut existing) => {
existing.extend(AutoScalingInstancesDeserializer::deserialize(
"AutoScalingInstances",
stack,
)?);
Some(existing.to_vec())
}
None => Some(AutoScalingInstancesDeserializer::deserialize(
"AutoScalingInstances",
stack,
)?),
};
}
"NextToken" => {
obj.next_token =
Some(XmlStringDeserializer::deserialize("NextToken", stack)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct AutoScalingNotificationTypesDeserializer;
impl AutoScalingNotificationTypesDeserializer {
#[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(XmlStringMaxLen255Deserializer::deserialize(
"member", stack,
)?);
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
end_element(tag_name, stack)?;
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
struct AutoScalingNotificationTypesSerializer;
impl AutoScalingNotificationTypesSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.member.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
struct AvailabilityZonesDeserializer;
impl AvailabilityZonesDeserializer {
#[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(XmlStringMaxLen255Deserializer::deserialize(
"member", stack,
)?);
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
end_element(tag_name, stack)?;
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
struct AvailabilityZonesSerializer;
impl AvailabilityZonesSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.member.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct BatchDeleteScheduledActionAnswer {
pub failed_scheduled_actions: Option<Vec<FailedScheduledUpdateGroupActionRequest>>,
}
struct BatchDeleteScheduledActionAnswerDeserializer;
impl BatchDeleteScheduledActionAnswerDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<BatchDeleteScheduledActionAnswer, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = BatchDeleteScheduledActionAnswer::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[..] {
"FailedScheduledActions" => {
obj.failed_scheduled_actions = match obj.failed_scheduled_actions {
Some(ref mut existing) => {
existing.extend(FailedScheduledUpdateGroupActionRequestsDeserializer::deserialize("FailedScheduledActions", stack)?);
Some(existing.to_vec())
}
None => Some(FailedScheduledUpdateGroupActionRequestsDeserializer::deserialize("FailedScheduledActions", 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 BatchDeleteScheduledActionType {
pub auto_scaling_group_name: String,
pub scheduled_action_names: Vec<String>,
}
struct BatchDeleteScheduledActionTypeSerializer;
impl BatchDeleteScheduledActionTypeSerializer {
fn serialize(params: &mut Params, name: &str, obj: &BatchDeleteScheduledActionType) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "AutoScalingGroupName"),
&obj.auto_scaling_group_name,
);
ScheduledActionNamesSerializer::serialize(
params,
&format!("{}{}", prefix, "ScheduledActionNames"),
&obj.scheduled_action_names,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct BatchPutScheduledUpdateGroupActionAnswer {
pub failed_scheduled_update_group_actions: Option<Vec<FailedScheduledUpdateGroupActionRequest>>,
}
struct BatchPutScheduledUpdateGroupActionAnswerDeserializer;
impl BatchPutScheduledUpdateGroupActionAnswerDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<BatchPutScheduledUpdateGroupActionAnswer, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = BatchPutScheduledUpdateGroupActionAnswer::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[..] {
"FailedScheduledUpdateGroupActions" => {
obj.failed_scheduled_update_group_actions = match obj.failed_scheduled_update_group_actions {
Some(ref mut existing) => {
existing.extend(FailedScheduledUpdateGroupActionRequestsDeserializer::deserialize("FailedScheduledUpdateGroupActions", stack)?);
Some(existing.to_vec())
}
None => Some(FailedScheduledUpdateGroupActionRequestsDeserializer::deserialize("FailedScheduledUpdateGroupActions", 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 BatchPutScheduledUpdateGroupActionType {
pub auto_scaling_group_name: String,
pub scheduled_update_group_actions: Vec<ScheduledUpdateGroupActionRequest>,
}
struct BatchPutScheduledUpdateGroupActionTypeSerializer;
impl BatchPutScheduledUpdateGroupActionTypeSerializer {
fn serialize(params: &mut Params, name: &str, obj: &BatchPutScheduledUpdateGroupActionType) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "AutoScalingGroupName"),
&obj.auto_scaling_group_name,
);
ScheduledUpdateGroupActionRequestsSerializer::serialize(
params,
&format!("{}{}", prefix, "ScheduledUpdateGroupActions"),
&obj.scheduled_update_group_actions,
);
}
}
struct BlockDeviceEbsDeleteOnTerminationDeserializer;
impl BlockDeviceEbsDeleteOnTerminationDeserializer {
#[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 BlockDeviceEbsEncryptedDeserializer;
impl BlockDeviceEbsEncryptedDeserializer {
#[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 BlockDeviceEbsIopsDeserializer;
impl BlockDeviceEbsIopsDeserializer {
#[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 BlockDeviceEbsVolumeSizeDeserializer;
impl BlockDeviceEbsVolumeSizeDeserializer {
#[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 BlockDeviceEbsVolumeTypeDeserializer;
impl BlockDeviceEbsVolumeTypeDeserializer {
#[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 BlockDeviceMapping {
pub device_name: String,
pub ebs: Option<Ebs>,
pub no_device: Option<bool>,
pub virtual_name: Option<String>,
}
struct BlockDeviceMappingDeserializer;
impl BlockDeviceMappingDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<BlockDeviceMapping, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = BlockDeviceMapping::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[..] {
"DeviceName" => {
obj.device_name =
XmlStringMaxLen255Deserializer::deserialize("DeviceName", stack)?;
}
"Ebs" => {
obj.ebs = Some(EbsDeserializer::deserialize("Ebs", stack)?);
}
"NoDevice" => {
obj.no_device = Some(NoDeviceDeserializer::deserialize("NoDevice", stack)?);
}
"VirtualName" => {
obj.virtual_name = Some(XmlStringMaxLen255Deserializer::deserialize(
"VirtualName",
stack,
)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct BlockDeviceMappingSerializer;
impl BlockDeviceMappingSerializer {
fn serialize(params: &mut Params, name: &str, obj: &BlockDeviceMapping) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(&format!("{}{}", prefix, "DeviceName"), &obj.device_name);
if let Some(ref field_value) = obj.ebs {
EbsSerializer::serialize(params, &format!("{}{}", prefix, "Ebs"), field_value);
}
if let Some(ref field_value) = obj.no_device {
params.put(
&format!("{}{}", prefix, "NoDevice"),
&field_value.to_string(),
);
}
if let Some(ref field_value) = obj.virtual_name {
params.put(&format!("{}{}", prefix, "VirtualName"), &field_value);
}
}
}
struct BlockDeviceMappingsDeserializer;
impl BlockDeviceMappingsDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<BlockDeviceMapping>, 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(BlockDeviceMappingDeserializer::deserialize(
"member", stack,
)?);
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
end_element(tag_name, stack)?;
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
struct BlockDeviceMappingsSerializer;
impl BlockDeviceMappingsSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<BlockDeviceMapping>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.member.{}", name, index + 1);
BlockDeviceMappingSerializer::serialize(params, &key, obj);
}
}
}
struct ClassicLinkVPCSecurityGroupsDeserializer;
impl ClassicLinkVPCSecurityGroupsDeserializer {
#[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(XmlStringMaxLen255Deserializer::deserialize(
"member", stack,
)?);
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
end_element(tag_name, stack)?;
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
struct ClassicLinkVPCSecurityGroupsSerializer;
impl ClassicLinkVPCSecurityGroupsSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.member.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CompleteLifecycleActionAnswer {}
struct CompleteLifecycleActionAnswerDeserializer;
impl CompleteLifecycleActionAnswerDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CompleteLifecycleActionAnswer, XmlParseError> {
start_element(tag_name, stack)?;
let obj = CompleteLifecycleActionAnswer::default();
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CompleteLifecycleActionType {
pub auto_scaling_group_name: String,
pub instance_id: Option<String>,
pub lifecycle_action_result: String,
pub lifecycle_action_token: Option<String>,
pub lifecycle_hook_name: String,
}
struct CompleteLifecycleActionTypeSerializer;
impl CompleteLifecycleActionTypeSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CompleteLifecycleActionType) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "AutoScalingGroupName"),
&obj.auto_scaling_group_name,
);
if let Some(ref field_value) = obj.instance_id {
params.put(&format!("{}{}", prefix, "InstanceId"), &field_value);
}
params.put(
&format!("{}{}", prefix, "LifecycleActionResult"),
&obj.lifecycle_action_result,
);
if let Some(ref field_value) = obj.lifecycle_action_token {
params.put(
&format!("{}{}", prefix, "LifecycleActionToken"),
&field_value,
);
}
params.put(
&format!("{}{}", prefix, "LifecycleHookName"),
&obj.lifecycle_hook_name,
);
}
}
struct CooldownDeserializer;
impl CooldownDeserializer {
#[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 CreateAutoScalingGroupType {
pub auto_scaling_group_name: String,
pub availability_zones: Option<Vec<String>>,
pub default_cooldown: Option<i64>,
pub desired_capacity: Option<i64>,
pub health_check_grace_period: Option<i64>,
pub health_check_type: Option<String>,
pub instance_id: Option<String>,
pub launch_configuration_name: Option<String>,
pub launch_template: Option<LaunchTemplateSpecification>,
pub lifecycle_hook_specification_list: Option<Vec<LifecycleHookSpecification>>,
pub load_balancer_names: Option<Vec<String>>,
pub max_size: i64,
pub min_size: i64,
pub mixed_instances_policy: Option<MixedInstancesPolicy>,
pub new_instances_protected_from_scale_in: Option<bool>,
pub placement_group: Option<String>,
pub service_linked_role_arn: Option<String>,
pub tags: Option<Vec<Tag>>,
pub target_group_ar_ns: Option<Vec<String>>,
pub termination_policies: Option<Vec<String>>,
pub vpc_zone_identifier: Option<String>,
}
struct CreateAutoScalingGroupTypeSerializer;
impl CreateAutoScalingGroupTypeSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CreateAutoScalingGroupType) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "AutoScalingGroupName"),
&obj.auto_scaling_group_name,
);
if let Some(ref field_value) = obj.availability_zones {
AvailabilityZonesSerializer::serialize(
params,
&format!("{}{}", prefix, "AvailabilityZones"),
field_value,
);
}
if let Some(ref field_value) = obj.default_cooldown {
params.put(
&format!("{}{}", prefix, "DefaultCooldown"),
&field_value.to_string(),
);
}
if let Some(ref field_value) = obj.desired_capacity {
params.put(
&format!("{}{}", prefix, "DesiredCapacity"),
&field_value.to_string(),
);
}
if let Some(ref field_value) = obj.health_check_grace_period {
params.put(
&format!("{}{}", prefix, "HealthCheckGracePeriod"),
&field_value.to_string(),
);
}
if let Some(ref field_value) = obj.health_check_type {
params.put(&format!("{}{}", prefix, "HealthCheckType"), &field_value);
}
if let Some(ref field_value) = obj.instance_id {
params.put(&format!("{}{}", prefix, "InstanceId"), &field_value);
}
if let Some(ref field_value) = obj.launch_configuration_name {
params.put(
&format!("{}{}", prefix, "LaunchConfigurationName"),
&field_value,
);
}
if let Some(ref field_value) = obj.launch_template {
LaunchTemplateSpecificationSerializer::serialize(
params,
&format!("{}{}", prefix, "LaunchTemplate"),
field_value,
);
}
if let Some(ref field_value) = obj.lifecycle_hook_specification_list {
LifecycleHookSpecificationsSerializer::serialize(
params,
&format!("{}{}", prefix, "LifecycleHookSpecificationList"),
field_value,
);
}
if let Some(ref field_value) = obj.load_balancer_names {
LoadBalancerNamesSerializer::serialize(
params,
&format!("{}{}", prefix, "LoadBalancerNames"),
field_value,
);
}
params.put(
&format!("{}{}", prefix, "MaxSize"),
&obj.max_size.to_string(),
);
params.put(
&format!("{}{}", prefix, "MinSize"),
&obj.min_size.to_string(),
);
if let Some(ref field_value) = obj.mixed_instances_policy {
MixedInstancesPolicySerializer::serialize(
params,
&format!("{}{}", prefix, "MixedInstancesPolicy"),
field_value,
);
}
if let Some(ref field_value) = obj.new_instances_protected_from_scale_in {
params.put(
&format!("{}{}", prefix, "NewInstancesProtectedFromScaleIn"),
&field_value.to_string(),
);
}
if let Some(ref field_value) = obj.placement_group {
params.put(&format!("{}{}", prefix, "PlacementGroup"), &field_value);
}
if let Some(ref field_value) = obj.service_linked_role_arn {
params.put(
&format!("{}{}", prefix, "ServiceLinkedRoleARN"),
&field_value,
);
}
if let Some(ref field_value) = obj.tags {
TagsSerializer::serialize(params, &format!("{}{}", prefix, "Tags"), field_value);
}
if let Some(ref field_value) = obj.target_group_ar_ns {
TargetGroupARNsSerializer::serialize(
params,
&format!("{}{}", prefix, "TargetGroupARNs"),
field_value,
);
}
if let Some(ref field_value) = obj.termination_policies {
TerminationPoliciesSerializer::serialize(
params,
&format!("{}{}", prefix, "TerminationPolicies"),
field_value,
);
}
if let Some(ref field_value) = obj.vpc_zone_identifier {
params.put(&format!("{}{}", prefix, "VPCZoneIdentifier"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateLaunchConfigurationType {
pub associate_public_ip_address: Option<bool>,
pub block_device_mappings: Option<Vec<BlockDeviceMapping>>,
pub classic_link_vpc_id: Option<String>,
pub classic_link_vpc_security_groups: Option<Vec<String>>,
pub ebs_optimized: Option<bool>,
pub iam_instance_profile: Option<String>,
pub image_id: Option<String>,
pub instance_id: Option<String>,
pub instance_monitoring: Option<InstanceMonitoring>,
pub instance_type: Option<String>,
pub kernel_id: Option<String>,
pub key_name: Option<String>,
pub launch_configuration_name: String,
pub placement_tenancy: Option<String>,
pub ramdisk_id: Option<String>,
pub security_groups: Option<Vec<String>>,
pub spot_price: Option<String>,
pub user_data: Option<String>,
}
struct CreateLaunchConfigurationTypeSerializer;
impl CreateLaunchConfigurationTypeSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CreateLaunchConfigurationType) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.associate_public_ip_address {
params.put(
&format!("{}{}", prefix, "AssociatePublicIpAddress"),
&field_value.to_string(),
);
}
if let Some(ref field_value) = obj.block_device_mappings {
BlockDeviceMappingsSerializer::serialize(
params,
&format!("{}{}", prefix, "BlockDeviceMappings"),
field_value,
);
}
if let Some(ref field_value) = obj.classic_link_vpc_id {
params.put(&format!("{}{}", prefix, "ClassicLinkVPCId"), &field_value);
}
if let Some(ref field_value) = obj.classic_link_vpc_security_groups {
ClassicLinkVPCSecurityGroupsSerializer::serialize(
params,
&format!("{}{}", prefix, "ClassicLinkVPCSecurityGroups"),
field_value,
);
}
if let Some(ref field_value) = obj.ebs_optimized {
params.put(
&format!("{}{}", prefix, "EbsOptimized"),
&field_value.to_string(),
);
}
if let Some(ref field_value) = obj.iam_instance_profile {
params.put(&format!("{}{}", prefix, "IamInstanceProfile"), &field_value);
}
if let Some(ref field_value) = obj.image_id {
params.put(&format!("{}{}", prefix, "ImageId"), &field_value);
}
if let Some(ref field_value) = obj.instance_id {
params.put(&format!("{}{}", prefix, "InstanceId"), &field_value);
}
if let Some(ref field_value) = obj.instance_monitoring {
InstanceMonitoringSerializer::serialize(
params,
&format!("{}{}", prefix, "InstanceMonitoring"),
field_value,
);
}
if let Some(ref field_value) = obj.instance_type {
params.put(&format!("{}{}", prefix, "InstanceType"), &field_value);
}
if let Some(ref field_value) = obj.kernel_id {
params.put(&format!("{}{}", prefix, "KernelId"), &field_value);
}
if let Some(ref field_value) = obj.key_name {
params.put(&format!("{}{}", prefix, "KeyName"), &field_value);
}
params.put(
&format!("{}{}", prefix, "LaunchConfigurationName"),
&obj.launch_configuration_name,
);
if let Some(ref field_value) = obj.placement_tenancy {
params.put(&format!("{}{}", prefix, "PlacementTenancy"), &field_value);
}
if let Some(ref field_value) = obj.ramdisk_id {
params.put(&format!("{}{}", prefix, "RamdiskId"), &field_value);
}
if let Some(ref field_value) = obj.security_groups {
SecurityGroupsSerializer::serialize(
params,
&format!("{}{}", prefix, "SecurityGroups"),
field_value,
);
}
if let Some(ref field_value) = obj.spot_price {
params.put(&format!("{}{}", prefix, "SpotPrice"), &field_value);
}
if let Some(ref field_value) = obj.user_data {
params.put(&format!("{}{}", prefix, "UserData"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateOrUpdateTagsType {
pub tags: Vec<Tag>,
}
struct CreateOrUpdateTagsTypeSerializer;
impl CreateOrUpdateTagsTypeSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CreateOrUpdateTagsType) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
TagsSerializer::serialize(params, &format!("{}{}", prefix, "Tags"), &obj.tags);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CustomizedMetricSpecification {
pub dimensions: Option<Vec<MetricDimension>>,
pub metric_name: String,
pub namespace: String,
pub statistic: String,
pub unit: Option<String>,
}
struct CustomizedMetricSpecificationDeserializer;
impl CustomizedMetricSpecificationDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CustomizedMetricSpecification, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = CustomizedMetricSpecification::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[..] {
"Dimensions" => {
obj.dimensions = match obj.dimensions {
Some(ref mut existing) => {
existing.extend(MetricDimensionsDeserializer::deserialize(
"Dimensions",
stack,
)?);
Some(existing.to_vec())
}
None => Some(MetricDimensionsDeserializer::deserialize(
"Dimensions",
stack,
)?),
};
}
"MetricName" => {
obj.metric_name = MetricNameDeserializer::deserialize("MetricName", stack)?;
}
"Namespace" => {
obj.namespace =
MetricNamespaceDeserializer::deserialize("Namespace", stack)?;
}
"Statistic" => {
obj.statistic =
MetricStatisticDeserializer::deserialize("Statistic", stack)?;
}
"Unit" => {
obj.unit = Some(MetricUnitDeserializer::deserialize("Unit", stack)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct CustomizedMetricSpecificationSerializer;
impl CustomizedMetricSpecificationSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CustomizedMetricSpecification) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dimensions {
MetricDimensionsSerializer::serialize(
params,
&format!("{}{}", prefix, "Dimensions"),
field_value,
);
}
params.put(&format!("{}{}", prefix, "MetricName"), &obj.metric_name);
params.put(&format!("{}{}", prefix, "Namespace"), &obj.namespace);
params.put(&format!("{}{}", prefix, "Statistic"), &obj.statistic);
if let Some(ref field_value) = obj.unit {
params.put(&format!("{}{}", prefix, "Unit"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DeleteAutoScalingGroupType {
pub auto_scaling_group_name: String,
pub force_delete: Option<bool>,
}
struct DeleteAutoScalingGroupTypeSerializer;
impl DeleteAutoScalingGroupTypeSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DeleteAutoScalingGroupType) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "AutoScalingGroupName"),
&obj.auto_scaling_group_name,
);
if let Some(ref field_value) = obj.force_delete {
params.put(
&format!("{}{}", prefix, "ForceDelete"),
&field_value.to_string(),
);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DeleteLifecycleHookAnswer {}
struct DeleteLifecycleHookAnswerDeserializer;
impl DeleteLifecycleHookAnswerDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DeleteLifecycleHookAnswer, XmlParseError> {
start_element(tag_name, stack)?;
let obj = DeleteLifecycleHookAnswer::default();
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DeleteLifecycleHookType {
pub auto_scaling_group_name: String,
pub lifecycle_hook_name: String,
}
struct DeleteLifecycleHookTypeSerializer;
impl DeleteLifecycleHookTypeSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DeleteLifecycleHookType) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "AutoScalingGroupName"),
&obj.auto_scaling_group_name,
);
params.put(
&format!("{}{}", prefix, "LifecycleHookName"),
&obj.lifecycle_hook_name,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DeleteNotificationConfigurationType {
pub auto_scaling_group_name: String,
pub topic_arn: String,
}
struct DeleteNotificationConfigurationTypeSerializer;
impl DeleteNotificationConfigurationTypeSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DeleteNotificationConfigurationType) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "AutoScalingGroupName"),
&obj.auto_scaling_group_name,
);
params.put(&format!("{}{}", prefix, "TopicARN"), &obj.topic_arn);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DeletePolicyType {
pub auto_scaling_group_name: Option<String>,
pub policy_name: String,
}
struct DeletePolicyTypeSerializer;
impl DeletePolicyTypeSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DeletePolicyType) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.auto_scaling_group_name {
params.put(
&format!("{}{}", prefix, "AutoScalingGroupName"),
&field_value,
);
}
params.put(&format!("{}{}", prefix, "PolicyName"), &obj.policy_name);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DeleteScheduledActionType {
pub auto_scaling_group_name: String,
pub scheduled_action_name: String,
}
struct DeleteScheduledActionTypeSerializer;
impl DeleteScheduledActionTypeSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DeleteScheduledActionType) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "AutoScalingGroupName"),
&obj.auto_scaling_group_name,
);
params.put(
&format!("{}{}", prefix, "ScheduledActionName"),
&obj.scheduled_action_name,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DeleteTagsType {
pub tags: Vec<Tag>,
}
struct DeleteTagsTypeSerializer;
impl DeleteTagsTypeSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DeleteTagsType) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
TagsSerializer::serialize(params, &format!("{}{}", prefix, "Tags"), &obj.tags);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeAccountLimitsAnswer {
pub max_number_of_auto_scaling_groups: Option<i64>,
pub max_number_of_launch_configurations: Option<i64>,
pub number_of_auto_scaling_groups: Option<i64>,
pub number_of_launch_configurations: Option<i64>,
}
struct DescribeAccountLimitsAnswerDeserializer;
impl DescribeAccountLimitsAnswerDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeAccountLimitsAnswer, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = DescribeAccountLimitsAnswer::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[..] {
"MaxNumberOfAutoScalingGroups" => {
obj.max_number_of_auto_scaling_groups =
Some(MaxNumberOfAutoScalingGroupsDeserializer::deserialize(
"MaxNumberOfAutoScalingGroups",
stack,
)?);
}
"MaxNumberOfLaunchConfigurations" => {
obj.max_number_of_launch_configurations =
Some(MaxNumberOfLaunchConfigurationsDeserializer::deserialize(
"MaxNumberOfLaunchConfigurations",
stack,
)?);
}
"NumberOfAutoScalingGroups" => {
obj.number_of_auto_scaling_groups =
Some(NumberOfAutoScalingGroupsDeserializer::deserialize(
"NumberOfAutoScalingGroups",
stack,
)?);
}
"NumberOfLaunchConfigurations" => {
obj.number_of_launch_configurations =
Some(NumberOfLaunchConfigurationsDeserializer::deserialize(
"NumberOfLaunchConfigurations",
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 DescribeAdjustmentTypesAnswer {
pub adjustment_types: Option<Vec<AdjustmentType>>,
}
struct DescribeAdjustmentTypesAnswerDeserializer;
impl DescribeAdjustmentTypesAnswerDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeAdjustmentTypesAnswer, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = DescribeAdjustmentTypesAnswer::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[..] {
"AdjustmentTypes" => {
obj.adjustment_types = match obj.adjustment_types {
Some(ref mut existing) => {
existing.extend(AdjustmentTypesDeserializer::deserialize(
"AdjustmentTypes",
stack,
)?);
Some(existing.to_vec())
}
None => Some(AdjustmentTypesDeserializer::deserialize(
"AdjustmentTypes",
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 DescribeAutoScalingInstancesType {
pub instance_ids: Option<Vec<String>>,
pub max_records: Option<i64>,
pub next_token: Option<String>,
}
struct DescribeAutoScalingInstancesTypeSerializer;
impl DescribeAutoScalingInstancesTypeSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeAutoScalingInstancesType) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.instance_ids {
InstanceIdsSerializer::serialize(
params,
&format!("{}{}", prefix, "InstanceIds"),
field_value,
);
}
if let Some(ref field_value) = obj.max_records {
params.put(
&format!("{}{}", prefix, "MaxRecords"),
&field_value.to_string(),
);
}
if let Some(ref field_value) = obj.next_token {
params.put(&format!("{}{}", prefix, "NextToken"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeAutoScalingNotificationTypesAnswer {
pub auto_scaling_notification_types: Option<Vec<String>>,
}
struct DescribeAutoScalingNotificationTypesAnswerDeserializer;
impl DescribeAutoScalingNotificationTypesAnswerDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeAutoScalingNotificationTypesAnswer, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = DescribeAutoScalingNotificationTypesAnswer::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[..] {
"AutoScalingNotificationTypes" => {
obj.auto_scaling_notification_types = match obj
.auto_scaling_notification_types
{
Some(ref mut existing) => {
existing.extend(
AutoScalingNotificationTypesDeserializer::deserialize(
"AutoScalingNotificationTypes",
stack,
)?,
);
Some(existing.to_vec())
}
None => Some(AutoScalingNotificationTypesDeserializer::deserialize(
"AutoScalingNotificationTypes",
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 DescribeLifecycleHookTypesAnswer {
pub lifecycle_hook_types: Option<Vec<String>>,
}
struct DescribeLifecycleHookTypesAnswerDeserializer;
impl DescribeLifecycleHookTypesAnswerDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeLifecycleHookTypesAnswer, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = DescribeLifecycleHookTypesAnswer::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[..] {
"LifecycleHookTypes" => {
obj.lifecycle_hook_types = match obj.lifecycle_hook_types {
Some(ref mut existing) => {
existing.extend(
AutoScalingNotificationTypesDeserializer::deserialize(
"LifecycleHookTypes",
stack,
)?,
);
Some(existing.to_vec())
}
None => Some(AutoScalingNotificationTypesDeserializer::deserialize(
"LifecycleHookTypes",
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 DescribeLifecycleHooksAnswer {
pub lifecycle_hooks: Option<Vec<LifecycleHook>>,
}
struct DescribeLifecycleHooksAnswerDeserializer;
impl DescribeLifecycleHooksAnswerDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeLifecycleHooksAnswer, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = DescribeLifecycleHooksAnswer::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[..] {
"LifecycleHooks" => {
obj.lifecycle_hooks = match obj.lifecycle_hooks {
Some(ref mut existing) => {
existing.extend(LifecycleHooksDeserializer::deserialize(
"LifecycleHooks",
stack,
)?);
Some(existing.to_vec())
}
None => Some(LifecycleHooksDeserializer::deserialize(
"LifecycleHooks",
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 DescribeLifecycleHooksType {
pub auto_scaling_group_name: String,
pub lifecycle_hook_names: Option<Vec<String>>,
}
struct DescribeLifecycleHooksTypeSerializer;
impl DescribeLifecycleHooksTypeSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeLifecycleHooksType) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "AutoScalingGroupName"),
&obj.auto_scaling_group_name,
);
if let Some(ref field_value) = obj.lifecycle_hook_names {
LifecycleHookNamesSerializer::serialize(
params,
&format!("{}{}", prefix, "LifecycleHookNames"),
field_value,
);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeLoadBalancerTargetGroupsRequest {
pub auto_scaling_group_name: String,
pub max_records: Option<i64>,
pub next_token: Option<String>,
}
struct DescribeLoadBalancerTargetGroupsRequestSerializer;
impl DescribeLoadBalancerTargetGroupsRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeLoadBalancerTargetGroupsRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "AutoScalingGroupName"),
&obj.auto_scaling_group_name,
);
if let Some(ref field_value) = obj.max_records {
params.put(
&format!("{}{}", prefix, "MaxRecords"),
&field_value.to_string(),
);
}
if let Some(ref field_value) = obj.next_token {
params.put(&format!("{}{}", prefix, "NextToken"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeLoadBalancerTargetGroupsResponse {
pub load_balancer_target_groups: Option<Vec<LoadBalancerTargetGroupState>>,
pub next_token: Option<String>,
}
struct DescribeLoadBalancerTargetGroupsResponseDeserializer;
impl DescribeLoadBalancerTargetGroupsResponseDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeLoadBalancerTargetGroupsResponse, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = DescribeLoadBalancerTargetGroupsResponse::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[..] {
"LoadBalancerTargetGroups" => {
obj.load_balancer_target_groups = match obj.load_balancer_target_groups {
Some(ref mut existing) => {
existing.extend(
LoadBalancerTargetGroupStatesDeserializer::deserialize(
"LoadBalancerTargetGroups",
stack,
)?,
);
Some(existing.to_vec())
}
None => Some(LoadBalancerTargetGroupStatesDeserializer::deserialize(
"LoadBalancerTargetGroups",
stack,
)?),
};
}
"NextToken" => {
obj.next_token =
Some(XmlStringDeserializer::deserialize("NextToken", 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 DescribeLoadBalancersRequest {
pub auto_scaling_group_name: String,
pub max_records: Option<i64>,
pub next_token: Option<String>,
}
struct DescribeLoadBalancersRequestSerializer;
impl DescribeLoadBalancersRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeLoadBalancersRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "AutoScalingGroupName"),
&obj.auto_scaling_group_name,
);
if let Some(ref field_value) = obj.max_records {
params.put(
&format!("{}{}", prefix, "MaxRecords"),
&field_value.to_string(),
);
}
if let Some(ref field_value) = obj.next_token {
params.put(&format!("{}{}", prefix, "NextToken"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeLoadBalancersResponse {
pub load_balancers: Option<Vec<LoadBalancerState>>,
pub next_token: Option<String>,
}
struct DescribeLoadBalancersResponseDeserializer;
impl DescribeLoadBalancersResponseDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeLoadBalancersResponse, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = DescribeLoadBalancersResponse::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[..] {
"LoadBalancers" => {
obj.load_balancers = match obj.load_balancers {
Some(ref mut existing) => {
existing.extend(LoadBalancerStatesDeserializer::deserialize(
"LoadBalancers",
stack,
)?);
Some(existing.to_vec())
}
None => Some(LoadBalancerStatesDeserializer::deserialize(
"LoadBalancers",
stack,
)?),
};
}
"NextToken" => {
obj.next_token =
Some(XmlStringDeserializer::deserialize("NextToken", 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 DescribeMetricCollectionTypesAnswer {
pub granularities: Option<Vec<MetricGranularityType>>,
pub metrics: Option<Vec<MetricCollectionType>>,
}
struct DescribeMetricCollectionTypesAnswerDeserializer;
impl DescribeMetricCollectionTypesAnswerDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeMetricCollectionTypesAnswer, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = DescribeMetricCollectionTypesAnswer::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[..] {
"Granularities" => {
obj.granularities = match obj.granularities {
Some(ref mut existing) => {
existing.extend(MetricGranularityTypesDeserializer::deserialize(
"Granularities",
stack,
)?);
Some(existing.to_vec())
}
None => Some(MetricGranularityTypesDeserializer::deserialize(
"Granularities",
stack,
)?),
};
}
"Metrics" => {
obj.metrics = match obj.metrics {
Some(ref mut existing) => {
existing.extend(MetricCollectionTypesDeserializer::deserialize(
"Metrics", stack,
)?);
Some(existing.to_vec())
}
None => Some(MetricCollectionTypesDeserializer::deserialize(
"Metrics", 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 DescribeNotificationConfigurationsAnswer {
pub next_token: Option<String>,
pub notification_configurations: Vec<NotificationConfiguration>,
}
struct DescribeNotificationConfigurationsAnswerDeserializer;
impl DescribeNotificationConfigurationsAnswerDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeNotificationConfigurationsAnswer, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = DescribeNotificationConfigurationsAnswer::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(XmlStringDeserializer::deserialize("NextToken", stack)?);
}
"NotificationConfigurations" => {
obj.notification_configurations.extend(
NotificationConfigurationsDeserializer::deserialize(
"NotificationConfigurations",
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 DescribeNotificationConfigurationsType {
pub auto_scaling_group_names: Option<Vec<String>>,
pub max_records: Option<i64>,
pub next_token: Option<String>,
}
struct DescribeNotificationConfigurationsTypeSerializer;
impl DescribeNotificationConfigurationsTypeSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeNotificationConfigurationsType) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.auto_scaling_group_names {
AutoScalingGroupNamesSerializer::serialize(
params,
&format!("{}{}", prefix, "AutoScalingGroupNames"),
field_value,
);
}
if let Some(ref field_value) = obj.max_records {
params.put(
&format!("{}{}", prefix, "MaxRecords"),
&field_value.to_string(),
);
}
if let Some(ref field_value) = obj.next_token {
params.put(&format!("{}{}", prefix, "NextToken"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribePoliciesType {
pub auto_scaling_group_name: Option<String>,
pub max_records: Option<i64>,
pub next_token: Option<String>,
pub policy_names: Option<Vec<String>>,
pub policy_types: Option<Vec<String>>,
}
struct DescribePoliciesTypeSerializer;
impl DescribePoliciesTypeSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribePoliciesType) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.auto_scaling_group_name {
params.put(
&format!("{}{}", prefix, "AutoScalingGroupName"),
&field_value,
);
}
if let Some(ref field_value) = obj.max_records {
params.put(
&format!("{}{}", prefix, "MaxRecords"),
&field_value.to_string(),
);
}
if let Some(ref field_value) = obj.next_token {
params.put(&format!("{}{}", prefix, "NextToken"), &field_value);
}
if let Some(ref field_value) = obj.policy_names {
PolicyNamesSerializer::serialize(
params,
&format!("{}{}", prefix, "PolicyNames"),
field_value,
);
}
if let Some(ref field_value) = obj.policy_types {
PolicyTypesSerializer::serialize(
params,
&format!("{}{}", prefix, "PolicyTypes"),
field_value,
);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeScalingActivitiesType {
pub activity_ids: Option<Vec<String>>,
pub auto_scaling_group_name: Option<String>,
pub max_records: Option<i64>,
pub next_token: Option<String>,
}
struct DescribeScalingActivitiesTypeSerializer;
impl DescribeScalingActivitiesTypeSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeScalingActivitiesType) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.activity_ids {
ActivityIdsSerializer::serialize(
params,
&format!("{}{}", prefix, "ActivityIds"),
field_value,
);
}
if let Some(ref field_value) = obj.auto_scaling_group_name {
params.put(
&format!("{}{}", prefix, "AutoScalingGroupName"),
&field_value,
);
}
if let Some(ref field_value) = obj.max_records {
params.put(
&format!("{}{}", prefix, "MaxRecords"),
&field_value.to_string(),
);
}
if let Some(ref field_value) = obj.next_token {
params.put(&format!("{}{}", prefix, "NextToken"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeScheduledActionsType {
pub auto_scaling_group_name: Option<String>,
pub end_time: Option<String>,
pub max_records: Option<i64>,
pub next_token: Option<String>,
pub scheduled_action_names: Option<Vec<String>>,
pub start_time: Option<String>,
}
struct DescribeScheduledActionsTypeSerializer;
impl DescribeScheduledActionsTypeSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeScheduledActionsType) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.auto_scaling_group_name {
params.put(
&format!("{}{}", prefix, "AutoScalingGroupName"),
&field_value,
);
}
if let Some(ref field_value) = obj.end_time {
params.put(&format!("{}{}", prefix, "EndTime"), &field_value);
}
if let Some(ref field_value) = obj.max_records {
params.put(
&format!("{}{}", prefix, "MaxRecords"),
&field_value.to_string(),
);
}
if let Some(ref field_value) = obj.next_token {
params.put(&format!("{}{}", prefix, "NextToken"), &field_value);
}
if let Some(ref field_value) = obj.scheduled_action_names {
ScheduledActionNamesSerializer::serialize(
params,
&format!("{}{}", prefix, "ScheduledActionNames"),
field_value,
);
}
if let Some(ref field_value) = obj.start_time {
params.put(&format!("{}{}", prefix, "StartTime"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeTagsType {
pub filters: Option<Vec<Filter>>,
pub max_records: Option<i64>,
pub next_token: Option<String>,
}
struct DescribeTagsTypeSerializer;
impl DescribeTagsTypeSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeTagsType) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.filters {
FiltersSerializer::serialize(params, &format!("{}{}", prefix, "Filters"), field_value);
}
if let Some(ref field_value) = obj.max_records {
params.put(
&format!("{}{}", prefix, "MaxRecords"),
&field_value.to_string(),
);
}
if let Some(ref field_value) = obj.next_token {
params.put(&format!("{}{}", prefix, "NextToken"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeTerminationPolicyTypesAnswer {
pub termination_policy_types: Option<Vec<String>>,
}
struct DescribeTerminationPolicyTypesAnswerDeserializer;
impl DescribeTerminationPolicyTypesAnswerDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeTerminationPolicyTypesAnswer, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = DescribeTerminationPolicyTypesAnswer::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[..] {
"TerminationPolicyTypes" => {
obj.termination_policy_types = match obj.termination_policy_types {
Some(ref mut existing) => {
existing.extend(TerminationPoliciesDeserializer::deserialize(
"TerminationPolicyTypes",
stack,
)?);
Some(existing.to_vec())
}
None => Some(TerminationPoliciesDeserializer::deserialize(
"TerminationPolicyTypes",
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 DetachInstancesAnswer {
pub activities: Option<Vec<Activity>>,
}
struct DetachInstancesAnswerDeserializer;
impl DetachInstancesAnswerDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DetachInstancesAnswer, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = DetachInstancesAnswer::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[..] {
"Activities" => {
obj.activities = match obj.activities {
Some(ref mut existing) => {
existing.extend(ActivitiesDeserializer::deserialize(
"Activities",
stack,
)?);
Some(existing.to_vec())
}
None => Some(ActivitiesDeserializer::deserialize("Activities", 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 DetachInstancesQuery {
pub auto_scaling_group_name: String,
pub instance_ids: Option<Vec<String>>,
pub should_decrement_desired_capacity: bool,
}
struct DetachInstancesQuerySerializer;
impl DetachInstancesQuerySerializer {
fn serialize(params: &mut Params, name: &str, obj: &DetachInstancesQuery) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "AutoScalingGroupName"),
&obj.auto_scaling_group_name,
);
if let Some(ref field_value) = obj.instance_ids {
InstanceIdsSerializer::serialize(
params,
&format!("{}{}", prefix, "InstanceIds"),
field_value,
);
}
params.put(
&format!("{}{}", prefix, "ShouldDecrementDesiredCapacity"),
&obj.should_decrement_desired_capacity.to_string(),
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DetachLoadBalancerTargetGroupsResultType {}
struct DetachLoadBalancerTargetGroupsResultTypeDeserializer;
impl DetachLoadBalancerTargetGroupsResultTypeDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DetachLoadBalancerTargetGroupsResultType, XmlParseError> {
start_element(tag_name, stack)?;
let obj = DetachLoadBalancerTargetGroupsResultType::default();
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DetachLoadBalancerTargetGroupsType {
pub auto_scaling_group_name: String,
pub target_group_ar_ns: Vec<String>,
}
struct DetachLoadBalancerTargetGroupsTypeSerializer;
impl DetachLoadBalancerTargetGroupsTypeSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DetachLoadBalancerTargetGroupsType) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "AutoScalingGroupName"),
&obj.auto_scaling_group_name,
);
TargetGroupARNsSerializer::serialize(
params,
&format!("{}{}", prefix, "TargetGroupARNs"),
&obj.target_group_ar_ns,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DetachLoadBalancersResultType {}
struct DetachLoadBalancersResultTypeDeserializer;
impl DetachLoadBalancersResultTypeDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DetachLoadBalancersResultType, XmlParseError> {
start_element(tag_name, stack)?;
let obj = DetachLoadBalancersResultType::default();
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DetachLoadBalancersType {
pub auto_scaling_group_name: String,
pub load_balancer_names: Vec<String>,
}
struct DetachLoadBalancersTypeSerializer;
impl DetachLoadBalancersTypeSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DetachLoadBalancersType) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "AutoScalingGroupName"),
&obj.auto_scaling_group_name,
);
LoadBalancerNamesSerializer::serialize(
params,
&format!("{}{}", prefix, "LoadBalancerNames"),
&obj.load_balancer_names,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DisableMetricsCollectionQuery {
pub auto_scaling_group_name: String,
pub metrics: Option<Vec<String>>,
}
struct DisableMetricsCollectionQuerySerializer;
impl DisableMetricsCollectionQuerySerializer {
fn serialize(params: &mut Params, name: &str, obj: &DisableMetricsCollectionQuery) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "AutoScalingGroupName"),
&obj.auto_scaling_group_name,
);
if let Some(ref field_value) = obj.metrics {
MetricsSerializer::serialize(params, &format!("{}{}", prefix, "Metrics"), field_value);
}
}
}
struct DisableScaleInDeserializer;
impl DisableScaleInDeserializer {
#[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)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct Ebs {
pub delete_on_termination: Option<bool>,
pub encrypted: Option<bool>,
pub iops: Option<i64>,
pub snapshot_id: Option<String>,
pub volume_size: Option<i64>,
pub volume_type: Option<String>,
}
struct EbsDeserializer;
impl EbsDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Ebs, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = Ebs::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[..] {
"DeleteOnTermination" => {
obj.delete_on_termination =
Some(BlockDeviceEbsDeleteOnTerminationDeserializer::deserialize(
"DeleteOnTermination",
stack,
)?);
}
"Encrypted" => {
obj.encrypted = Some(BlockDeviceEbsEncryptedDeserializer::deserialize(
"Encrypted",
stack,
)?);
}
"Iops" => {
obj.iops =
Some(BlockDeviceEbsIopsDeserializer::deserialize("Iops", stack)?);
}
"SnapshotId" => {
obj.snapshot_id = Some(XmlStringMaxLen255Deserializer::deserialize(
"SnapshotId",
stack,
)?);
}
"VolumeSize" => {
obj.volume_size = Some(BlockDeviceEbsVolumeSizeDeserializer::deserialize(
"VolumeSize",
stack,
)?);
}
"VolumeType" => {
obj.volume_type = Some(BlockDeviceEbsVolumeTypeDeserializer::deserialize(
"VolumeType",
stack,
)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct EbsSerializer;
impl EbsSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Ebs) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.delete_on_termination {
params.put(
&format!("{}{}", prefix, "DeleteOnTermination"),
&field_value.to_string(),
);
}
if let Some(ref field_value) = obj.encrypted {
params.put(
&format!("{}{}", prefix, "Encrypted"),
&field_value.to_string(),
);
}
if let Some(ref field_value) = obj.iops {
params.put(&format!("{}{}", prefix, "Iops"), &field_value.to_string());
}
if let Some(ref field_value) = obj.snapshot_id {
params.put(&format!("{}{}", prefix, "SnapshotId"), &field_value);
}
if let Some(ref field_value) = obj.volume_size {
params.put(
&format!("{}{}", prefix, "VolumeSize"),
&field_value.to_string(),
);
}
if let Some(ref field_value) = obj.volume_type {
params.put(&format!("{}{}", prefix, "VolumeType"), &field_value);
}
}
}
struct EbsOptimizedDeserializer;
impl EbsOptimizedDeserializer {
#[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)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct EnableMetricsCollectionQuery {
pub auto_scaling_group_name: String,
pub granularity: String,
pub metrics: Option<Vec<String>>,
}
struct EnableMetricsCollectionQuerySerializer;
impl EnableMetricsCollectionQuerySerializer {
fn serialize(params: &mut Params, name: &str, obj: &EnableMetricsCollectionQuery) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "AutoScalingGroupName"),
&obj.auto_scaling_group_name,
);
params.put(&format!("{}{}", prefix, "Granularity"), &obj.granularity);
if let Some(ref field_value) = obj.metrics {
MetricsSerializer::serialize(params, &format!("{}{}", prefix, "Metrics"), field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct EnabledMetric {
pub granularity: Option<String>,
pub metric: Option<String>,
}
struct EnabledMetricDeserializer;
impl EnabledMetricDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<EnabledMetric, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = EnabledMetric::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[..] {
"Granularity" => {
obj.granularity = Some(XmlStringMaxLen255Deserializer::deserialize(
"Granularity",
stack,
)?);
}
"Metric" => {
obj.metric = Some(XmlStringMaxLen255Deserializer::deserialize(
"Metric", stack,
)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct EnabledMetricsDeserializer;
impl EnabledMetricsDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<EnabledMetric>, 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(EnabledMetricDeserializer::deserialize("member", 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 EnterStandbyAnswer {
pub activities: Option<Vec<Activity>>,
}
struct EnterStandbyAnswerDeserializer;
impl EnterStandbyAnswerDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<EnterStandbyAnswer, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = EnterStandbyAnswer::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[..] {
"Activities" => {
obj.activities = match obj.activities {
Some(ref mut existing) => {
existing.extend(ActivitiesDeserializer::deserialize(
"Activities",
stack,
)?);
Some(existing.to_vec())
}
None => Some(ActivitiesDeserializer::deserialize("Activities", 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 EnterStandbyQuery {
pub auto_scaling_group_name: String,
pub instance_ids: Option<Vec<String>>,
pub should_decrement_desired_capacity: bool,
}
struct EnterStandbyQuerySerializer;
impl EnterStandbyQuerySerializer {
fn serialize(params: &mut Params, name: &str, obj: &EnterStandbyQuery) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "AutoScalingGroupName"),
&obj.auto_scaling_group_name,
);
if let Some(ref field_value) = obj.instance_ids {
InstanceIdsSerializer::serialize(
params,
&format!("{}{}", prefix, "InstanceIds"),
field_value,
);
}
params.put(
&format!("{}{}", prefix, "ShouldDecrementDesiredCapacity"),
&obj.should_decrement_desired_capacity.to_string(),
);
}
}
struct EstimatedInstanceWarmupDeserializer;
impl EstimatedInstanceWarmupDeserializer {
#[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 ExecutePolicyType {
pub auto_scaling_group_name: Option<String>,
pub breach_threshold: Option<f64>,
pub honor_cooldown: Option<bool>,
pub metric_value: Option<f64>,
pub policy_name: String,
}
struct ExecutePolicyTypeSerializer;
impl ExecutePolicyTypeSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ExecutePolicyType) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.auto_scaling_group_name {
params.put(
&format!("{}{}", prefix, "AutoScalingGroupName"),
&field_value,
);
}
if let Some(ref field_value) = obj.breach_threshold {
params.put(
&format!("{}{}", prefix, "BreachThreshold"),
&field_value.to_string(),
);
}
if let Some(ref field_value) = obj.honor_cooldown {
params.put(
&format!("{}{}", prefix, "HonorCooldown"),
&field_value.to_string(),
);
}
if let Some(ref field_value) = obj.metric_value {
params.put(
&format!("{}{}", prefix, "MetricValue"),
&field_value.to_string(),
);
}
params.put(&format!("{}{}", prefix, "PolicyName"), &obj.policy_name);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ExitStandbyAnswer {
pub activities: Option<Vec<Activity>>,
}
struct ExitStandbyAnswerDeserializer;
impl ExitStandbyAnswerDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ExitStandbyAnswer, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = ExitStandbyAnswer::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[..] {
"Activities" => {
obj.activities = match obj.activities {
Some(ref mut existing) => {
existing.extend(ActivitiesDeserializer::deserialize(
"Activities",
stack,
)?);
Some(existing.to_vec())
}
None => Some(ActivitiesDeserializer::deserialize("Activities", 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 ExitStandbyQuery {
pub auto_scaling_group_name: String,
pub instance_ids: Option<Vec<String>>,
}
struct ExitStandbyQuerySerializer;
impl ExitStandbyQuerySerializer {
fn serialize(params: &mut Params, name: &str, obj: &ExitStandbyQuery) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "AutoScalingGroupName"),
&obj.auto_scaling_group_name,
);
if let Some(ref field_value) = obj.instance_ids {
InstanceIdsSerializer::serialize(
params,
&format!("{}{}", prefix, "InstanceIds"),
field_value,
);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct FailedScheduledUpdateGroupActionRequest {
pub error_code: Option<String>,
pub error_message: Option<String>,
pub scheduled_action_name: String,
}
struct FailedScheduledUpdateGroupActionRequestDeserializer;
impl FailedScheduledUpdateGroupActionRequestDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<FailedScheduledUpdateGroupActionRequest, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = FailedScheduledUpdateGroupActionRequest::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[..] {
"ErrorCode" => {
obj.error_code = Some(XmlStringMaxLen64Deserializer::deserialize(
"ErrorCode",
stack,
)?);
}
"ErrorMessage" => {
obj.error_message =
Some(XmlStringDeserializer::deserialize("ErrorMessage", stack)?);
}
"ScheduledActionName" => {
obj.scheduled_action_name = XmlStringMaxLen255Deserializer::deserialize(
"ScheduledActionName",
stack,
)?;
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct FailedScheduledUpdateGroupActionRequestsDeserializer;
impl FailedScheduledUpdateGroupActionRequestsDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<FailedScheduledUpdateGroupActionRequest>, 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(
FailedScheduledUpdateGroupActionRequestDeserializer::deserialize(
"member", 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 Filter {
pub name: Option<String>,
pub values: Option<Vec<String>>,
}
struct FilterSerializer;
impl FilterSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Filter) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.name {
params.put(&format!("{}{}", prefix, "Name"), &field_value);
}
if let Some(ref field_value) = obj.values {
ValuesSerializer::serialize(params, &format!("{}{}", prefix, "Values"), field_value);
}
}
}
struct FiltersSerializer;
impl FiltersSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<Filter>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.member.{}", name, index + 1);
FilterSerializer::serialize(params, &key, obj);
}
}
}
struct GlobalTimeoutDeserializer;
impl GlobalTimeoutDeserializer {
#[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 HealthCheckGracePeriodDeserializer;
impl HealthCheckGracePeriodDeserializer {
#[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 HeartbeatTimeoutDeserializer;
impl HeartbeatTimeoutDeserializer {
#[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 Instance {
pub availability_zone: String,
pub health_status: String,
pub instance_id: String,
pub launch_configuration_name: Option<String>,
pub launch_template: Option<LaunchTemplateSpecification>,
pub lifecycle_state: String,
pub protected_from_scale_in: bool,
}
struct InstanceDeserializer;
impl InstanceDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Instance, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = Instance::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[..] {
"AvailabilityZone" => {
obj.availability_zone =
XmlStringMaxLen255Deserializer::deserialize("AvailabilityZone", stack)?;
}
"HealthStatus" => {
obj.health_status =
XmlStringMaxLen32Deserializer::deserialize("HealthStatus", stack)?;
}
"InstanceId" => {
obj.instance_id =
XmlStringMaxLen19Deserializer::deserialize("InstanceId", stack)?;
}
"LaunchConfigurationName" => {
obj.launch_configuration_name =
Some(XmlStringMaxLen255Deserializer::deserialize(
"LaunchConfigurationName",
stack,
)?);
}
"LaunchTemplate" => {
obj.launch_template =
Some(LaunchTemplateSpecificationDeserializer::deserialize(
"LaunchTemplate",
stack,
)?);
}
"LifecycleState" => {
obj.lifecycle_state =
LifecycleStateDeserializer::deserialize("LifecycleState", stack)?;
}
"ProtectedFromScaleIn" => {
obj.protected_from_scale_in = InstanceProtectedDeserializer::deserialize(
"ProtectedFromScaleIn",
stack,
)?;
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct InstanceIdsSerializer;
impl InstanceIdsSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.member.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct InstanceMonitoring {
pub enabled: Option<bool>,
}
struct InstanceMonitoringDeserializer;
impl InstanceMonitoringDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<InstanceMonitoring, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = InstanceMonitoring::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[..] {
"Enabled" => {
obj.enabled = Some(MonitoringEnabledDeserializer::deserialize(
"Enabled", stack,
)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct InstanceMonitoringSerializer;
impl InstanceMonitoringSerializer {
fn serialize(params: &mut Params, name: &str, obj: &InstanceMonitoring) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.enabled {
params.put(
&format!("{}{}", prefix, "Enabled"),
&field_value.to_string(),
);
}
}
}
struct InstanceProtectedDeserializer;
impl InstanceProtectedDeserializer {
#[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 InstancesDeserializer;
impl InstancesDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<Instance>, 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(InstanceDeserializer::deserialize("member", 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 InstancesDistribution {
pub on_demand_allocation_strategy: Option<String>,
pub on_demand_base_capacity: Option<i64>,
pub on_demand_percentage_above_base_capacity: Option<i64>,
pub spot_allocation_strategy: Option<String>,
pub spot_instance_pools: Option<i64>,
pub spot_max_price: Option<String>,
}
struct InstancesDistributionDeserializer;
impl InstancesDistributionDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<InstancesDistribution, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = InstancesDistribution::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[..] {
"OnDemandAllocationStrategy" => {
obj.on_demand_allocation_strategy =
Some(XmlStringDeserializer::deserialize(
"OnDemandAllocationStrategy",
stack,
)?);
}
"OnDemandBaseCapacity" => {
obj.on_demand_base_capacity =
Some(OnDemandBaseCapacityDeserializer::deserialize(
"OnDemandBaseCapacity",
stack,
)?);
}
"OnDemandPercentageAboveBaseCapacity" => {
obj.on_demand_percentage_above_base_capacity = Some(
OnDemandPercentageAboveBaseCapacityDeserializer::deserialize(
"OnDemandPercentageAboveBaseCapacity",
stack,
)?,
);
}
"SpotAllocationStrategy" => {
obj.spot_allocation_strategy = Some(XmlStringDeserializer::deserialize(
"SpotAllocationStrategy",
stack,
)?);
}
"SpotInstancePools" => {
obj.spot_instance_pools = Some(SpotInstancePoolsDeserializer::deserialize(
"SpotInstancePools",
stack,
)?);
}
"SpotMaxPrice" => {
obj.spot_max_price =
Some(SpotPriceDeserializer::deserialize("SpotMaxPrice", stack)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct InstancesDistributionSerializer;
impl InstancesDistributionSerializer {
fn serialize(params: &mut Params, name: &str, obj: &InstancesDistribution) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.on_demand_allocation_strategy {
params.put(
&format!("{}{}", prefix, "OnDemandAllocationStrategy"),
&field_value,
);
}
if let Some(ref field_value) = obj.on_demand_base_capacity {
params.put(
&format!("{}{}", prefix, "OnDemandBaseCapacity"),
&field_value.to_string(),
);
}
if let Some(ref field_value) = obj.on_demand_percentage_above_base_capacity {
params.put(
&format!("{}{}", prefix, "OnDemandPercentageAboveBaseCapacity"),
&field_value.to_string(),
);
}
if let Some(ref field_value) = obj.spot_allocation_strategy {
params.put(
&format!("{}{}", prefix, "SpotAllocationStrategy"),
&field_value,
);
}
if let Some(ref field_value) = obj.spot_instance_pools {
params.put(
&format!("{}{}", prefix, "SpotInstancePools"),
&field_value.to_string(),
);
}
if let Some(ref field_value) = obj.spot_max_price {
params.put(&format!("{}{}", prefix, "SpotMaxPrice"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct LaunchConfiguration {
pub associate_public_ip_address: Option<bool>,
pub block_device_mappings: Option<Vec<BlockDeviceMapping>>,
pub classic_link_vpc_id: Option<String>,
pub classic_link_vpc_security_groups: Option<Vec<String>>,
pub created_time: String,
pub ebs_optimized: Option<bool>,
pub iam_instance_profile: Option<String>,
pub image_id: String,
pub instance_monitoring: Option<InstanceMonitoring>,
pub instance_type: String,
pub kernel_id: Option<String>,
pub key_name: Option<String>,
pub launch_configuration_arn: Option<String>,
pub launch_configuration_name: String,
pub placement_tenancy: Option<String>,
pub ramdisk_id: Option<String>,
pub security_groups: Option<Vec<String>>,
pub spot_price: Option<String>,
pub user_data: Option<String>,
}
struct LaunchConfigurationDeserializer;
impl LaunchConfigurationDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<LaunchConfiguration, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = LaunchConfiguration::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[..] {
"AssociatePublicIpAddress" => {
obj.associate_public_ip_address =
Some(AssociatePublicIpAddressDeserializer::deserialize(
"AssociatePublicIpAddress",
stack,
)?);
}
"BlockDeviceMappings" => {
obj.block_device_mappings = match obj.block_device_mappings {
Some(ref mut existing) => {
existing.extend(BlockDeviceMappingsDeserializer::deserialize(
"BlockDeviceMappings",
stack,
)?);
Some(existing.to_vec())
}
None => Some(BlockDeviceMappingsDeserializer::deserialize(
"BlockDeviceMappings",
stack,
)?),
};
}
"ClassicLinkVPCId" => {
obj.classic_link_vpc_id = Some(
XmlStringMaxLen255Deserializer::deserialize("ClassicLinkVPCId", stack)?,
);
}
"ClassicLinkVPCSecurityGroups" => {
obj.classic_link_vpc_security_groups = match obj
.classic_link_vpc_security_groups
{
Some(ref mut existing) => {
existing.extend(
ClassicLinkVPCSecurityGroupsDeserializer::deserialize(
"ClassicLinkVPCSecurityGroups",
stack,
)?,
);
Some(existing.to_vec())
}
None => Some(ClassicLinkVPCSecurityGroupsDeserializer::deserialize(
"ClassicLinkVPCSecurityGroups",
stack,
)?),
};
}
"CreatedTime" => {
obj.created_time =
TimestampTypeDeserializer::deserialize("CreatedTime", stack)?;
}
"EbsOptimized" => {
obj.ebs_optimized = Some(EbsOptimizedDeserializer::deserialize(
"EbsOptimized",
stack,
)?);
}
"IamInstanceProfile" => {
obj.iam_instance_profile =
Some(XmlStringMaxLen1600Deserializer::deserialize(
"IamInstanceProfile",
stack,
)?);
}
"ImageId" => {
obj.image_id =
XmlStringMaxLen255Deserializer::deserialize("ImageId", stack)?;
}
"InstanceMonitoring" => {
obj.instance_monitoring =
Some(InstanceMonitoringDeserializer::deserialize(
"InstanceMonitoring",
stack,
)?);
}
"InstanceType" => {
obj.instance_type =
XmlStringMaxLen255Deserializer::deserialize("InstanceType", stack)?;
}
"KernelId" => {
obj.kernel_id = Some(XmlStringMaxLen255Deserializer::deserialize(
"KernelId", stack,
)?);
}
"KeyName" => {
obj.key_name = Some(XmlStringMaxLen255Deserializer::deserialize(
"KeyName", stack,
)?);
}
"LaunchConfigurationARN" => {
obj.launch_configuration_arn = Some(ResourceNameDeserializer::deserialize(
"LaunchConfigurationARN",
stack,
)?);
}
"LaunchConfigurationName" => {
obj.launch_configuration_name =
XmlStringMaxLen255Deserializer::deserialize(
"LaunchConfigurationName",
stack,
)?;
}
"PlacementTenancy" => {
obj.placement_tenancy = Some(XmlStringMaxLen64Deserializer::deserialize(
"PlacementTenancy",
stack,
)?);
}
"RamdiskId" => {
obj.ramdisk_id = Some(XmlStringMaxLen255Deserializer::deserialize(
"RamdiskId",
stack,
)?);
}
"SecurityGroups" => {
obj.security_groups = match obj.security_groups {
Some(ref mut existing) => {
existing.extend(SecurityGroupsDeserializer::deserialize(
"SecurityGroups",
stack,
)?);
Some(existing.to_vec())
}
None => Some(SecurityGroupsDeserializer::deserialize(
"SecurityGroups",
stack,
)?),
};
}
"SpotPrice" => {
obj.spot_price =
Some(SpotPriceDeserializer::deserialize("SpotPrice", stack)?);
}
"UserData" => {
obj.user_data = Some(XmlStringUserDataDeserializer::deserialize(
"UserData", 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 LaunchConfigurationNameType {
pub launch_configuration_name: String,
}
struct LaunchConfigurationNameTypeSerializer;
impl LaunchConfigurationNameTypeSerializer {
fn serialize(params: &mut Params, name: &str, obj: &LaunchConfigurationNameType) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "LaunchConfigurationName"),
&obj.launch_configuration_name,
);
}
}
struct LaunchConfigurationNamesSerializer;
impl LaunchConfigurationNamesSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.member.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct LaunchConfigurationNamesType {
pub launch_configuration_names: Option<Vec<String>>,
pub max_records: Option<i64>,
pub next_token: Option<String>,
}
struct LaunchConfigurationNamesTypeSerializer;
impl LaunchConfigurationNamesTypeSerializer {
fn serialize(params: &mut Params, name: &str, obj: &LaunchConfigurationNamesType) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.launch_configuration_names {
LaunchConfigurationNamesSerializer::serialize(
params,
&format!("{}{}", prefix, "LaunchConfigurationNames"),
field_value,
);
}
if let Some(ref field_value) = obj.max_records {
params.put(
&format!("{}{}", prefix, "MaxRecords"),
&field_value.to_string(),
);
}
if let Some(ref field_value) = obj.next_token {
params.put(&format!("{}{}", prefix, "NextToken"), &field_value);
}
}
}
struct LaunchConfigurationsDeserializer;
impl LaunchConfigurationsDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<LaunchConfiguration>, 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(LaunchConfigurationDeserializer::deserialize(
"member", 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 LaunchConfigurationsType {
pub launch_configurations: Vec<LaunchConfiguration>,
pub next_token: Option<String>,
}
struct LaunchConfigurationsTypeDeserializer;
impl LaunchConfigurationsTypeDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<LaunchConfigurationsType, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = LaunchConfigurationsType::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[..] {
"LaunchConfigurations" => {
obj.launch_configurations.extend(
LaunchConfigurationsDeserializer::deserialize(
"LaunchConfigurations",
stack,
)?,
);
}
"NextToken" => {
obj.next_token =
Some(XmlStringDeserializer::deserialize("NextToken", 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 LaunchTemplate {
pub launch_template_specification: Option<LaunchTemplateSpecification>,
pub overrides: Option<Vec<LaunchTemplateOverrides>>,
}
struct LaunchTemplateDeserializer;
impl LaunchTemplateDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<LaunchTemplate, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = LaunchTemplate::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[..] {
"LaunchTemplateSpecification" => {
obj.launch_template_specification =
Some(LaunchTemplateSpecificationDeserializer::deserialize(
"LaunchTemplateSpecification",
stack,
)?);
}
"Overrides" => {
obj.overrides = match obj.overrides {
Some(ref mut existing) => {
existing.extend(OverridesDeserializer::deserialize(
"Overrides",
stack,
)?);
Some(existing.to_vec())
}
None => Some(OverridesDeserializer::deserialize("Overrides", stack)?),
};
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct LaunchTemplateSerializer;
impl LaunchTemplateSerializer {
fn serialize(params: &mut Params, name: &str, obj: &LaunchTemplate) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.launch_template_specification {
LaunchTemplateSpecificationSerializer::serialize(
params,
&format!("{}{}", prefix, "LaunchTemplateSpecification"),
field_value,
);
}
if let Some(ref field_value) = obj.overrides {
OverridesSerializer::serialize(
params,
&format!("{}{}", prefix, "Overrides"),
field_value,
);
}
}
}
struct LaunchTemplateNameDeserializer;
impl LaunchTemplateNameDeserializer {
#[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 LaunchTemplateOverrides {
pub instance_type: Option<String>,
}
struct LaunchTemplateOverridesDeserializer;
impl LaunchTemplateOverridesDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<LaunchTemplateOverrides, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = LaunchTemplateOverrides::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[..] {
"InstanceType" => {
obj.instance_type = Some(XmlStringMaxLen255Deserializer::deserialize(
"InstanceType",
stack,
)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct LaunchTemplateOverridesSerializer;
impl LaunchTemplateOverridesSerializer {
fn serialize(params: &mut Params, name: &str, obj: &LaunchTemplateOverrides) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.instance_type {
params.put(&format!("{}{}", prefix, "InstanceType"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct LaunchTemplateSpecification {
pub launch_template_id: Option<String>,
pub launch_template_name: Option<String>,
pub version: Option<String>,
}
struct LaunchTemplateSpecificationDeserializer;
impl LaunchTemplateSpecificationDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<LaunchTemplateSpecification, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = LaunchTemplateSpecification::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[..] {
"LaunchTemplateId" => {
obj.launch_template_id = Some(XmlStringMaxLen255Deserializer::deserialize(
"LaunchTemplateId",
stack,
)?);
}
"LaunchTemplateName" => {
obj.launch_template_name =
Some(LaunchTemplateNameDeserializer::deserialize(
"LaunchTemplateName",
stack,
)?);
}
"Version" => {
obj.version = Some(XmlStringMaxLen255Deserializer::deserialize(
"Version", stack,
)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct LaunchTemplateSpecificationSerializer;
impl LaunchTemplateSpecificationSerializer {
fn serialize(params: &mut Params, name: &str, obj: &LaunchTemplateSpecification) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.launch_template_id {
params.put(&format!("{}{}", prefix, "LaunchTemplateId"), &field_value);
}
if let Some(ref field_value) = obj.launch_template_name {
params.put(&format!("{}{}", prefix, "LaunchTemplateName"), &field_value);
}
if let Some(ref field_value) = obj.version {
params.put(&format!("{}{}", prefix, "Version"), &field_value);
}
}
}
struct LifecycleActionResultDeserializer;
impl LifecycleActionResultDeserializer {
#[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 LifecycleHook {
pub auto_scaling_group_name: Option<String>,
pub default_result: Option<String>,
pub global_timeout: Option<i64>,
pub heartbeat_timeout: Option<i64>,
pub lifecycle_hook_name: Option<String>,
pub lifecycle_transition: Option<String>,
pub notification_metadata: Option<String>,
pub notification_target_arn: Option<String>,
pub role_arn: Option<String>,
}
struct LifecycleHookDeserializer;
impl LifecycleHookDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<LifecycleHook, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = LifecycleHook::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[..] {
"AutoScalingGroupName" => {
obj.auto_scaling_group_name = Some(ResourceNameDeserializer::deserialize(
"AutoScalingGroupName",
stack,
)?);
}
"DefaultResult" => {
obj.default_result = Some(LifecycleActionResultDeserializer::deserialize(
"DefaultResult",
stack,
)?);
}
"GlobalTimeout" => {
obj.global_timeout = Some(GlobalTimeoutDeserializer::deserialize(
"GlobalTimeout",
stack,
)?);
}
"HeartbeatTimeout" => {
obj.heartbeat_timeout = Some(HeartbeatTimeoutDeserializer::deserialize(
"HeartbeatTimeout",
stack,
)?);
}
"LifecycleHookName" => {
obj.lifecycle_hook_name =
Some(AsciiStringMaxLen255Deserializer::deserialize(
"LifecycleHookName",
stack,
)?);
}
"LifecycleTransition" => {
obj.lifecycle_transition =
Some(LifecycleTransitionDeserializer::deserialize(
"LifecycleTransition",
stack,
)?);
}
"NotificationMetadata" => {
obj.notification_metadata =
Some(XmlStringMaxLen1023Deserializer::deserialize(
"NotificationMetadata",
stack,
)?);
}
"NotificationTargetARN" => {
obj.notification_target_arn = Some(ResourceNameDeserializer::deserialize(
"NotificationTargetARN",
stack,
)?);
}
"RoleARN" => {
obj.role_arn =
Some(ResourceNameDeserializer::deserialize("RoleARN", stack)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct LifecycleHookNamesSerializer;
impl LifecycleHookNamesSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.member.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct LifecycleHookSpecification {
pub default_result: Option<String>,
pub heartbeat_timeout: Option<i64>,
pub lifecycle_hook_name: String,
pub lifecycle_transition: String,
pub notification_metadata: Option<String>,
pub notification_target_arn: Option<String>,
pub role_arn: Option<String>,
}
struct LifecycleHookSpecificationSerializer;
impl LifecycleHookSpecificationSerializer {
fn serialize(params: &mut Params, name: &str, obj: &LifecycleHookSpecification) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.default_result {
params.put(&format!("{}{}", prefix, "DefaultResult"), &field_value);
}
if let Some(ref field_value) = obj.heartbeat_timeout {
params.put(
&format!("{}{}", prefix, "HeartbeatTimeout"),
&field_value.to_string(),
);
}
params.put(
&format!("{}{}", prefix, "LifecycleHookName"),
&obj.lifecycle_hook_name,
);
params.put(
&format!("{}{}", prefix, "LifecycleTransition"),
&obj.lifecycle_transition,
);
if let Some(ref field_value) = obj.notification_metadata {
params.put(
&format!("{}{}", prefix, "NotificationMetadata"),
&field_value,
);
}
if let Some(ref field_value) = obj.notification_target_arn {
params.put(
&format!("{}{}", prefix, "NotificationTargetARN"),
&field_value,
);
}
if let Some(ref field_value) = obj.role_arn {
params.put(&format!("{}{}", prefix, "RoleARN"), &field_value);
}
}
}
struct LifecycleHookSpecificationsSerializer;
impl LifecycleHookSpecificationsSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<LifecycleHookSpecification>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.member.{}", name, index + 1);
LifecycleHookSpecificationSerializer::serialize(params, &key, obj);
}
}
}
struct LifecycleHooksDeserializer;
impl LifecycleHooksDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<LifecycleHook>, 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(LifecycleHookDeserializer::deserialize("member", stack)?);
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
end_element(tag_name, stack)?;
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
struct LifecycleStateDeserializer;
impl LifecycleStateDeserializer {
#[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 LifecycleTransitionDeserializer;
impl LifecycleTransitionDeserializer {
#[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 LoadBalancerNamesDeserializer;
impl LoadBalancerNamesDeserializer {
#[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(XmlStringMaxLen255Deserializer::deserialize(
"member", stack,
)?);
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
end_element(tag_name, stack)?;
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
struct LoadBalancerNamesSerializer;
impl LoadBalancerNamesSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.member.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct LoadBalancerState {
pub load_balancer_name: Option<String>,
pub state: Option<String>,
}
struct LoadBalancerStateDeserializer;
impl LoadBalancerStateDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<LoadBalancerState, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = LoadBalancerState::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[..] {
"LoadBalancerName" => {
obj.load_balancer_name = Some(XmlStringMaxLen255Deserializer::deserialize(
"LoadBalancerName",
stack,
)?);
}
"State" => {
obj.state =
Some(XmlStringMaxLen255Deserializer::deserialize("State", stack)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct LoadBalancerStatesDeserializer;
impl LoadBalancerStatesDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<LoadBalancerState>, 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(LoadBalancerStateDeserializer::deserialize("member", 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 LoadBalancerTargetGroupState {
pub load_balancer_target_group_arn: Option<String>,
pub state: Option<String>,
}
struct LoadBalancerTargetGroupStateDeserializer;
impl LoadBalancerTargetGroupStateDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<LoadBalancerTargetGroupState, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = LoadBalancerTargetGroupState::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[..] {
"LoadBalancerTargetGroupARN" => {
obj.load_balancer_target_group_arn =
Some(XmlStringMaxLen511Deserializer::deserialize(
"LoadBalancerTargetGroupARN",
stack,
)?);
}
"State" => {
obj.state =
Some(XmlStringMaxLen255Deserializer::deserialize("State", stack)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct LoadBalancerTargetGroupStatesDeserializer;
impl LoadBalancerTargetGroupStatesDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<LoadBalancerTargetGroupState>, 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(LoadBalancerTargetGroupStateDeserializer::deserialize(
"member", stack,
)?);
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
end_element(tag_name, stack)?;
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
struct MaxNumberOfAutoScalingGroupsDeserializer;
impl MaxNumberOfAutoScalingGroupsDeserializer {
#[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 MaxNumberOfLaunchConfigurationsDeserializer;
impl MaxNumberOfLaunchConfigurationsDeserializer {
#[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 MetricCollectionType {
pub metric: Option<String>,
}
struct MetricCollectionTypeDeserializer;
impl MetricCollectionTypeDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<MetricCollectionType, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = MetricCollectionType::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[..] {
"Metric" => {
obj.metric = Some(XmlStringMaxLen255Deserializer::deserialize(
"Metric", stack,
)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct MetricCollectionTypesDeserializer;
impl MetricCollectionTypesDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<MetricCollectionType>, 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(MetricCollectionTypeDeserializer::deserialize(
"member", 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 MetricDimension {
pub name: String,
pub value: String,
}
struct MetricDimensionDeserializer;
impl MetricDimensionDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<MetricDimension, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = MetricDimension::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 = MetricDimensionNameDeserializer::deserialize("Name", stack)?;
}
"Value" => {
obj.value = MetricDimensionValueDeserializer::deserialize("Value", stack)?;
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct MetricDimensionSerializer;
impl MetricDimensionSerializer {
fn serialize(params: &mut Params, name: &str, obj: &MetricDimension) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(&format!("{}{}", prefix, "Name"), &obj.name);
params.put(&format!("{}{}", prefix, "Value"), &obj.value);
}
}
struct MetricDimensionNameDeserializer;
impl MetricDimensionNameDeserializer {
#[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 MetricDimensionValueDeserializer;
impl MetricDimensionValueDeserializer {
#[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 MetricDimensionsDeserializer;
impl MetricDimensionsDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<MetricDimension>, 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(MetricDimensionDeserializer::deserialize("member", stack)?);
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
end_element(tag_name, stack)?;
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
struct MetricDimensionsSerializer;
impl MetricDimensionsSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<MetricDimension>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.member.{}", name, index + 1);
MetricDimensionSerializer::serialize(params, &key, obj);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct MetricGranularityType {
pub granularity: Option<String>,
}
struct MetricGranularityTypeDeserializer;
impl MetricGranularityTypeDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<MetricGranularityType, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = MetricGranularityType::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[..] {
"Granularity" => {
obj.granularity = Some(XmlStringMaxLen255Deserializer::deserialize(
"Granularity",
stack,
)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct MetricGranularityTypesDeserializer;
impl MetricGranularityTypesDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<MetricGranularityType>, 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(MetricGranularityTypeDeserializer::deserialize(
"member", stack,
)?);
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
end_element(tag_name, stack)?;
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
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 MetricNamespaceDeserializer;
impl MetricNamespaceDeserializer {
#[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 MetricScaleDeserializer;
impl MetricScaleDeserializer {
#[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 MetricStatisticDeserializer;
impl MetricStatisticDeserializer {
#[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 MetricTypeDeserializer;
impl MetricTypeDeserializer {
#[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 MetricUnitDeserializer;
impl MetricUnitDeserializer {
#[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 MetricsSerializer;
impl MetricsSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.member.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
struct MinAdjustmentMagnitudeDeserializer;
impl MinAdjustmentMagnitudeDeserializer {
#[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 MinAdjustmentStepDeserializer;
impl MinAdjustmentStepDeserializer {
#[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 MixedInstancesPolicy {
pub instances_distribution: Option<InstancesDistribution>,
pub launch_template: Option<LaunchTemplate>,
}
struct MixedInstancesPolicyDeserializer;
impl MixedInstancesPolicyDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<MixedInstancesPolicy, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = MixedInstancesPolicy::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[..] {
"InstancesDistribution" => {
obj.instances_distribution =
Some(InstancesDistributionDeserializer::deserialize(
"InstancesDistribution",
stack,
)?);
}
"LaunchTemplate" => {
obj.launch_template = Some(LaunchTemplateDeserializer::deserialize(
"LaunchTemplate",
stack,
)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct MixedInstancesPolicySerializer;
impl MixedInstancesPolicySerializer {
fn serialize(params: &mut Params, name: &str, obj: &MixedInstancesPolicy) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.instances_distribution {
InstancesDistributionSerializer::serialize(
params,
&format!("{}{}", prefix, "InstancesDistribution"),
field_value,
);
}
if let Some(ref field_value) = obj.launch_template {
LaunchTemplateSerializer::serialize(
params,
&format!("{}{}", prefix, "LaunchTemplate"),
field_value,
);
}
}
}
struct MonitoringEnabledDeserializer;
impl MonitoringEnabledDeserializer {
#[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 NoDeviceDeserializer;
impl NoDeviceDeserializer {
#[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)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct NotificationConfiguration {
pub auto_scaling_group_name: Option<String>,
pub notification_type: Option<String>,
pub topic_arn: Option<String>,
}
struct NotificationConfigurationDeserializer;
impl NotificationConfigurationDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<NotificationConfiguration, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = NotificationConfiguration::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[..] {
"AutoScalingGroupName" => {
obj.auto_scaling_group_name = Some(ResourceNameDeserializer::deserialize(
"AutoScalingGroupName",
stack,
)?);
}
"NotificationType" => {
obj.notification_type = Some(XmlStringMaxLen255Deserializer::deserialize(
"NotificationType",
stack,
)?);
}
"TopicARN" => {
obj.topic_arn =
Some(ResourceNameDeserializer::deserialize("TopicARN", stack)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct NotificationConfigurationsDeserializer;
impl NotificationConfigurationsDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<NotificationConfiguration>, 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(NotificationConfigurationDeserializer::deserialize(
"member", stack,
)?);
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
end_element(tag_name, stack)?;
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
struct NumberOfAutoScalingGroupsDeserializer;
impl NumberOfAutoScalingGroupsDeserializer {
#[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 NumberOfLaunchConfigurationsDeserializer;
impl NumberOfLaunchConfigurationsDeserializer {
#[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 OnDemandBaseCapacityDeserializer;
impl OnDemandBaseCapacityDeserializer {
#[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 OnDemandPercentageAboveBaseCapacityDeserializer;
impl OnDemandPercentageAboveBaseCapacityDeserializer {
#[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 OverridesDeserializer;
impl OverridesDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<LaunchTemplateOverrides>, 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(LaunchTemplateOverridesDeserializer::deserialize(
"member", stack,
)?);
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
end_element(tag_name, stack)?;
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
struct OverridesSerializer;
impl OverridesSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<LaunchTemplateOverrides>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.member.{}", name, index + 1);
LaunchTemplateOverridesSerializer::serialize(params, &key, obj);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct PoliciesType {
pub next_token: Option<String>,
pub scaling_policies: Option<Vec<ScalingPolicy>>,
}
struct PoliciesTypeDeserializer;
impl PoliciesTypeDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<PoliciesType, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = PoliciesType::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(XmlStringDeserializer::deserialize("NextToken", stack)?);
}
"ScalingPolicies" => {
obj.scaling_policies = match obj.scaling_policies {
Some(ref mut existing) => {
existing.extend(ScalingPoliciesDeserializer::deserialize(
"ScalingPolicies",
stack,
)?);
Some(existing.to_vec())
}
None => Some(ScalingPoliciesDeserializer::deserialize(
"ScalingPolicies",
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 PolicyARNType {
pub alarms: Option<Vec<Alarm>>,
pub policy_arn: Option<String>,
}
struct PolicyARNTypeDeserializer;
impl PolicyARNTypeDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<PolicyARNType, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = PolicyARNType::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[..] {
"Alarms" => {
obj.alarms = match obj.alarms {
Some(ref mut existing) => {
existing.extend(AlarmsDeserializer::deserialize("Alarms", stack)?);
Some(existing.to_vec())
}
None => Some(AlarmsDeserializer::deserialize("Alarms", stack)?),
};
}
"PolicyARN" => {
obj.policy_arn =
Some(ResourceNameDeserializer::deserialize("PolicyARN", stack)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct PolicyIncrementDeserializer;
impl PolicyIncrementDeserializer {
#[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 PolicyNamesSerializer;
impl PolicyNamesSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.member.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
struct PolicyTypesSerializer;
impl PolicyTypesSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.member.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct PredefinedMetricSpecification {
pub predefined_metric_type: String,
pub resource_label: Option<String>,
}
struct PredefinedMetricSpecificationDeserializer;
impl PredefinedMetricSpecificationDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<PredefinedMetricSpecification, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = PredefinedMetricSpecification::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[..] {
"PredefinedMetricType" => {
obj.predefined_metric_type =
MetricTypeDeserializer::deserialize("PredefinedMetricType", stack)?;
}
"ResourceLabel" => {
obj.resource_label = Some(XmlStringMaxLen1023Deserializer::deserialize(
"ResourceLabel",
stack,
)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct PredefinedMetricSpecificationSerializer;
impl PredefinedMetricSpecificationSerializer {
fn serialize(params: &mut Params, name: &str, obj: &PredefinedMetricSpecification) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "PredefinedMetricType"),
&obj.predefined_metric_type,
);
if let Some(ref field_value) = obj.resource_label {
params.put(&format!("{}{}", prefix, "ResourceLabel"), &field_value);
}
}
}
struct ProcessNamesSerializer;
impl ProcessNamesSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.member.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ProcessType {
pub process_name: String,
}
struct ProcessTypeDeserializer;
impl ProcessTypeDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ProcessType, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = ProcessType::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[..] {
"ProcessName" => {
obj.process_name =
XmlStringMaxLen255Deserializer::deserialize("ProcessName", stack)?;
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct ProcessesDeserializer;
impl ProcessesDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<ProcessType>, 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(ProcessTypeDeserializer::deserialize("member", 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 ProcessesType {
pub processes: Option<Vec<ProcessType>>,
}
struct ProcessesTypeDeserializer;
impl ProcessesTypeDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ProcessesType, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = ProcessesType::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[..] {
"Processes" => {
obj.processes = match obj.processes {
Some(ref mut existing) => {
existing.extend(ProcessesDeserializer::deserialize(
"Processes",
stack,
)?);
Some(existing.to_vec())
}
None => Some(ProcessesDeserializer::deserialize("Processes", stack)?),
};
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct ProgressDeserializer;
impl ProgressDeserializer {
#[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 PropagateAtLaunchDeserializer;
impl PropagateAtLaunchDeserializer {
#[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)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct PutLifecycleHookAnswer {}
struct PutLifecycleHookAnswerDeserializer;
impl PutLifecycleHookAnswerDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<PutLifecycleHookAnswer, XmlParseError> {
start_element(tag_name, stack)?;
let obj = PutLifecycleHookAnswer::default();
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct PutLifecycleHookType {
pub auto_scaling_group_name: String,
pub default_result: Option<String>,
pub heartbeat_timeout: Option<i64>,
pub lifecycle_hook_name: String,
pub lifecycle_transition: Option<String>,
pub notification_metadata: Option<String>,
pub notification_target_arn: Option<String>,
pub role_arn: Option<String>,
}
struct PutLifecycleHookTypeSerializer;
impl PutLifecycleHookTypeSerializer {
fn serialize(params: &mut Params, name: &str, obj: &PutLifecycleHookType) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "AutoScalingGroupName"),
&obj.auto_scaling_group_name,
);
if let Some(ref field_value) = obj.default_result {
params.put(&format!("{}{}", prefix, "DefaultResult"), &field_value);
}
if let Some(ref field_value) = obj.heartbeat_timeout {
params.put(
&format!("{}{}", prefix, "HeartbeatTimeout"),
&field_value.to_string(),
);
}
params.put(
&format!("{}{}", prefix, "LifecycleHookName"),
&obj.lifecycle_hook_name,
);
if let Some(ref field_value) = obj.lifecycle_transition {
params.put(
&format!("{}{}", prefix, "LifecycleTransition"),
&field_value,
);
}
if let Some(ref field_value) = obj.notification_metadata {
params.put(
&format!("{}{}", prefix, "NotificationMetadata"),
&field_value,
);
}
if let Some(ref field_value) = obj.notification_target_arn {
params.put(
&format!("{}{}", prefix, "NotificationTargetARN"),
&field_value,
);
}
if let Some(ref field_value) = obj.role_arn {
params.put(&format!("{}{}", prefix, "RoleARN"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct PutNotificationConfigurationType {
pub auto_scaling_group_name: String,
pub notification_types: Vec<String>,
pub topic_arn: String,
}
struct PutNotificationConfigurationTypeSerializer;
impl PutNotificationConfigurationTypeSerializer {
fn serialize(params: &mut Params, name: &str, obj: &PutNotificationConfigurationType) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "AutoScalingGroupName"),
&obj.auto_scaling_group_name,
);
AutoScalingNotificationTypesSerializer::serialize(
params,
&format!("{}{}", prefix, "NotificationTypes"),
&obj.notification_types,
);
params.put(&format!("{}{}", prefix, "TopicARN"), &obj.topic_arn);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct PutScalingPolicyType {
pub adjustment_type: Option<String>,
pub auto_scaling_group_name: String,
pub cooldown: Option<i64>,
pub estimated_instance_warmup: Option<i64>,
pub metric_aggregation_type: Option<String>,
pub min_adjustment_magnitude: Option<i64>,
pub min_adjustment_step: Option<i64>,
pub policy_name: String,
pub policy_type: Option<String>,
pub scaling_adjustment: Option<i64>,
pub step_adjustments: Option<Vec<StepAdjustment>>,
pub target_tracking_configuration: Option<TargetTrackingConfiguration>,
}
struct PutScalingPolicyTypeSerializer;
impl PutScalingPolicyTypeSerializer {
fn serialize(params: &mut Params, name: &str, obj: &PutScalingPolicyType) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.adjustment_type {
params.put(&format!("{}{}", prefix, "AdjustmentType"), &field_value);
}
params.put(
&format!("{}{}", prefix, "AutoScalingGroupName"),
&obj.auto_scaling_group_name,
);
if let Some(ref field_value) = obj.cooldown {
params.put(
&format!("{}{}", prefix, "Cooldown"),
&field_value.to_string(),
);
}
if let Some(ref field_value) = obj.estimated_instance_warmup {
params.put(
&format!("{}{}", prefix, "EstimatedInstanceWarmup"),
&field_value.to_string(),
);
}
if let Some(ref field_value) = obj.metric_aggregation_type {
params.put(
&format!("{}{}", prefix, "MetricAggregationType"),
&field_value,
);
}
if let Some(ref field_value) = obj.min_adjustment_magnitude {
params.put(
&format!("{}{}", prefix, "MinAdjustmentMagnitude"),
&field_value.to_string(),
);
}
if let Some(ref field_value) = obj.min_adjustment_step {
params.put(
&format!("{}{}", prefix, "MinAdjustmentStep"),
&field_value.to_string(),
);
}
params.put(&format!("{}{}", prefix, "PolicyName"), &obj.policy_name);
if let Some(ref field_value) = obj.policy_type {
params.put(&format!("{}{}", prefix, "PolicyType"), &field_value);
}
if let Some(ref field_value) = obj.scaling_adjustment {
params.put(
&format!("{}{}", prefix, "ScalingAdjustment"),
&field_value.to_string(),
);
}
if let Some(ref field_value) = obj.step_adjustments {
StepAdjustmentsSerializer::serialize(
params,
&format!("{}{}", prefix, "StepAdjustments"),
field_value,
);
}
if let Some(ref field_value) = obj.target_tracking_configuration {
TargetTrackingConfigurationSerializer::serialize(
params,
&format!("{}{}", prefix, "TargetTrackingConfiguration"),
field_value,
);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct PutScheduledUpdateGroupActionType {
pub auto_scaling_group_name: String,
pub desired_capacity: Option<i64>,
pub end_time: Option<String>,
pub max_size: Option<i64>,
pub min_size: Option<i64>,
pub recurrence: Option<String>,
pub scheduled_action_name: String,
pub start_time: Option<String>,
pub time: Option<String>,
}
struct PutScheduledUpdateGroupActionTypeSerializer;
impl PutScheduledUpdateGroupActionTypeSerializer {
fn serialize(params: &mut Params, name: &str, obj: &PutScheduledUpdateGroupActionType) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "AutoScalingGroupName"),
&obj.auto_scaling_group_name,
);
if let Some(ref field_value) = obj.desired_capacity {
params.put(
&format!("{}{}", prefix, "DesiredCapacity"),
&field_value.to_string(),
);
}
if let Some(ref field_value) = obj.end_time {
params.put(&format!("{}{}", prefix, "EndTime"), &field_value);
}
if let Some(ref field_value) = obj.max_size {
params.put(
&format!("{}{}", prefix, "MaxSize"),
&field_value.to_string(),
);
}
if let Some(ref field_value) = obj.min_size {
params.put(
&format!("{}{}", prefix, "MinSize"),
&field_value.to_string(),
);
}
if let Some(ref field_value) = obj.recurrence {
params.put(&format!("{}{}", prefix, "Recurrence"), &field_value);
}
params.put(
&format!("{}{}", prefix, "ScheduledActionName"),
&obj.scheduled_action_name,
);
if let Some(ref field_value) = obj.start_time {
params.put(&format!("{}{}", prefix, "StartTime"), &field_value);
}
if let Some(ref field_value) = obj.time {
params.put(&format!("{}{}", prefix, "Time"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct RecordLifecycleActionHeartbeatAnswer {}
struct RecordLifecycleActionHeartbeatAnswerDeserializer;
impl RecordLifecycleActionHeartbeatAnswerDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<RecordLifecycleActionHeartbeatAnswer, XmlParseError> {
start_element(tag_name, stack)?;
let obj = RecordLifecycleActionHeartbeatAnswer::default();
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct RecordLifecycleActionHeartbeatType {
pub auto_scaling_group_name: String,
pub instance_id: Option<String>,
pub lifecycle_action_token: Option<String>,
pub lifecycle_hook_name: String,
}
struct RecordLifecycleActionHeartbeatTypeSerializer;
impl RecordLifecycleActionHeartbeatTypeSerializer {
fn serialize(params: &mut Params, name: &str, obj: &RecordLifecycleActionHeartbeatType) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "AutoScalingGroupName"),
&obj.auto_scaling_group_name,
);
if let Some(ref field_value) = obj.instance_id {
params.put(&format!("{}{}", prefix, "InstanceId"), &field_value);
}
if let Some(ref field_value) = obj.lifecycle_action_token {
params.put(
&format!("{}{}", prefix, "LifecycleActionToken"),
&field_value,
);
}
params.put(
&format!("{}{}", prefix, "LifecycleHookName"),
&obj.lifecycle_hook_name,
);
}
}
struct ResourceNameDeserializer;
impl ResourceNameDeserializer {
#[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 ScalingActivityStatusCodeDeserializer;
impl ScalingActivityStatusCodeDeserializer {
#[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 ScalingPoliciesDeserializer;
impl ScalingPoliciesDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<ScalingPolicy>, 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(ScalingPolicyDeserializer::deserialize("member", 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 ScalingPolicy {
pub adjustment_type: Option<String>,
pub alarms: Option<Vec<Alarm>>,
pub auto_scaling_group_name: Option<String>,
pub cooldown: Option<i64>,
pub estimated_instance_warmup: Option<i64>,
pub metric_aggregation_type: Option<String>,
pub min_adjustment_magnitude: Option<i64>,
pub min_adjustment_step: Option<i64>,
pub policy_arn: Option<String>,
pub policy_name: Option<String>,
pub policy_type: Option<String>,
pub scaling_adjustment: Option<i64>,
pub step_adjustments: Option<Vec<StepAdjustment>>,
pub target_tracking_configuration: Option<TargetTrackingConfiguration>,
}
struct ScalingPolicyDeserializer;
impl ScalingPolicyDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ScalingPolicy, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = ScalingPolicy::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[..] {
"AdjustmentType" => {
obj.adjustment_type = Some(XmlStringMaxLen255Deserializer::deserialize(
"AdjustmentType",
stack,
)?);
}
"Alarms" => {
obj.alarms = match obj.alarms {
Some(ref mut existing) => {
existing.extend(AlarmsDeserializer::deserialize("Alarms", stack)?);
Some(existing.to_vec())
}
None => Some(AlarmsDeserializer::deserialize("Alarms", stack)?),
};
}
"AutoScalingGroupName" => {
obj.auto_scaling_group_name =
Some(XmlStringMaxLen255Deserializer::deserialize(
"AutoScalingGroupName",
stack,
)?);
}
"Cooldown" => {
obj.cooldown = Some(CooldownDeserializer::deserialize("Cooldown", stack)?);
}
"EstimatedInstanceWarmup" => {
obj.estimated_instance_warmup =
Some(EstimatedInstanceWarmupDeserializer::deserialize(
"EstimatedInstanceWarmup",
stack,
)?);
}
"MetricAggregationType" => {
obj.metric_aggregation_type =
Some(XmlStringMaxLen32Deserializer::deserialize(
"MetricAggregationType",
stack,
)?);
}
"MinAdjustmentMagnitude" => {
obj.min_adjustment_magnitude =
Some(MinAdjustmentMagnitudeDeserializer::deserialize(
"MinAdjustmentMagnitude",
stack,
)?);
}
"MinAdjustmentStep" => {
obj.min_adjustment_step = Some(MinAdjustmentStepDeserializer::deserialize(
"MinAdjustmentStep",
stack,
)?);
}
"PolicyARN" => {
obj.policy_arn =
Some(ResourceNameDeserializer::deserialize("PolicyARN", stack)?);
}
"PolicyName" => {
obj.policy_name = Some(XmlStringMaxLen255Deserializer::deserialize(
"PolicyName",
stack,
)?);
}
"PolicyType" => {
obj.policy_type = Some(XmlStringMaxLen64Deserializer::deserialize(
"PolicyType",
stack,
)?);
}
"ScalingAdjustment" => {
obj.scaling_adjustment = Some(PolicyIncrementDeserializer::deserialize(
"ScalingAdjustment",
stack,
)?);
}
"StepAdjustments" => {
obj.step_adjustments = match obj.step_adjustments {
Some(ref mut existing) => {
existing.extend(StepAdjustmentsDeserializer::deserialize(
"StepAdjustments",
stack,
)?);
Some(existing.to_vec())
}
None => Some(StepAdjustmentsDeserializer::deserialize(
"StepAdjustments",
stack,
)?),
};
}
"TargetTrackingConfiguration" => {
obj.target_tracking_configuration =
Some(TargetTrackingConfigurationDeserializer::deserialize(
"TargetTrackingConfiguration",
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 ScalingProcessQuery {
pub auto_scaling_group_name: String,
pub scaling_processes: Option<Vec<String>>,
}
struct ScalingProcessQuerySerializer;
impl ScalingProcessQuerySerializer {
fn serialize(params: &mut Params, name: &str, obj: &ScalingProcessQuery) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "AutoScalingGroupName"),
&obj.auto_scaling_group_name,
);
if let Some(ref field_value) = obj.scaling_processes {
ProcessNamesSerializer::serialize(
params,
&format!("{}{}", prefix, "ScalingProcesses"),
field_value,
);
}
}
}
struct ScheduledActionNamesSerializer;
impl ScheduledActionNamesSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.member.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ScheduledActionsType {
pub next_token: Option<String>,
pub scheduled_update_group_actions: Option<Vec<ScheduledUpdateGroupAction>>,
}
struct ScheduledActionsTypeDeserializer;
impl ScheduledActionsTypeDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ScheduledActionsType, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = ScheduledActionsType::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(XmlStringDeserializer::deserialize("NextToken", stack)?);
}
"ScheduledUpdateGroupActions" => {
obj.scheduled_update_group_actions =
match obj.scheduled_update_group_actions {
Some(ref mut existing) => {
existing.extend(
ScheduledUpdateGroupActionsDeserializer::deserialize(
"ScheduledUpdateGroupActions",
stack,
)?,
);
Some(existing.to_vec())
}
None => Some(ScheduledUpdateGroupActionsDeserializer::deserialize(
"ScheduledUpdateGroupActions",
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 ScheduledUpdateGroupAction {
pub auto_scaling_group_name: Option<String>,
pub desired_capacity: Option<i64>,
pub end_time: Option<String>,
pub max_size: Option<i64>,
pub min_size: Option<i64>,
pub recurrence: Option<String>,
pub scheduled_action_arn: Option<String>,
pub scheduled_action_name: Option<String>,
pub start_time: Option<String>,
pub time: Option<String>,
}
struct ScheduledUpdateGroupActionDeserializer;
impl ScheduledUpdateGroupActionDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ScheduledUpdateGroupAction, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = ScheduledUpdateGroupAction::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[..] {
"AutoScalingGroupName" => {
obj.auto_scaling_group_name =
Some(XmlStringMaxLen255Deserializer::deserialize(
"AutoScalingGroupName",
stack,
)?);
}
"DesiredCapacity" => {
obj.desired_capacity =
Some(AutoScalingGroupDesiredCapacityDeserializer::deserialize(
"DesiredCapacity",
stack,
)?);
}
"EndTime" => {
obj.end_time =
Some(TimestampTypeDeserializer::deserialize("EndTime", stack)?);
}
"MaxSize" => {
obj.max_size = Some(AutoScalingGroupMaxSizeDeserializer::deserialize(
"MaxSize", stack,
)?);
}
"MinSize" => {
obj.min_size = Some(AutoScalingGroupMinSizeDeserializer::deserialize(
"MinSize", stack,
)?);
}
"Recurrence" => {
obj.recurrence = Some(XmlStringMaxLen255Deserializer::deserialize(
"Recurrence",
stack,
)?);
}
"ScheduledActionARN" => {
obj.scheduled_action_arn = Some(ResourceNameDeserializer::deserialize(
"ScheduledActionARN",
stack,
)?);
}
"ScheduledActionName" => {
obj.scheduled_action_name =
Some(XmlStringMaxLen255Deserializer::deserialize(
"ScheduledActionName",
stack,
)?);
}
"StartTime" => {
obj.start_time =
Some(TimestampTypeDeserializer::deserialize("StartTime", stack)?);
}
"Time" => {
obj.time = Some(TimestampTypeDeserializer::deserialize("Time", 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 ScheduledUpdateGroupActionRequest {
pub desired_capacity: Option<i64>,
pub end_time: Option<String>,
pub max_size: Option<i64>,
pub min_size: Option<i64>,
pub recurrence: Option<String>,
pub scheduled_action_name: String,
pub start_time: Option<String>,
}
struct ScheduledUpdateGroupActionRequestSerializer;
impl ScheduledUpdateGroupActionRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ScheduledUpdateGroupActionRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.desired_capacity {
params.put(
&format!("{}{}", prefix, "DesiredCapacity"),
&field_value.to_string(),
);
}
if let Some(ref field_value) = obj.end_time {
params.put(&format!("{}{}", prefix, "EndTime"), &field_value);
}
if let Some(ref field_value) = obj.max_size {
params.put(
&format!("{}{}", prefix, "MaxSize"),
&field_value.to_string(),
);
}
if let Some(ref field_value) = obj.min_size {
params.put(
&format!("{}{}", prefix, "MinSize"),
&field_value.to_string(),
);
}
if let Some(ref field_value) = obj.recurrence {
params.put(&format!("{}{}", prefix, "Recurrence"), &field_value);
}
params.put(
&format!("{}{}", prefix, "ScheduledActionName"),
&obj.scheduled_action_name,
);
if let Some(ref field_value) = obj.start_time {
params.put(&format!("{}{}", prefix, "StartTime"), &field_value);
}
}
}
struct ScheduledUpdateGroupActionRequestsSerializer;
impl ScheduledUpdateGroupActionRequestsSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<ScheduledUpdateGroupActionRequest>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.member.{}", name, index + 1);
ScheduledUpdateGroupActionRequestSerializer::serialize(params, &key, obj);
}
}
}
struct ScheduledUpdateGroupActionsDeserializer;
impl ScheduledUpdateGroupActionsDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<ScheduledUpdateGroupAction>, 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(ScheduledUpdateGroupActionDeserializer::deserialize(
"member", stack,
)?);
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
end_element(tag_name, stack)?;
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
struct SecurityGroupsDeserializer;
impl SecurityGroupsDeserializer {
#[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(XmlStringDeserializer::deserialize("member", stack)?);
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
end_element(tag_name, stack)?;
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
struct SecurityGroupsSerializer;
impl SecurityGroupsSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.member.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct SetDesiredCapacityType {
pub auto_scaling_group_name: String,
pub desired_capacity: i64,
pub honor_cooldown: Option<bool>,
}
struct SetDesiredCapacityTypeSerializer;
impl SetDesiredCapacityTypeSerializer {
fn serialize(params: &mut Params, name: &str, obj: &SetDesiredCapacityType) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "AutoScalingGroupName"),
&obj.auto_scaling_group_name,
);
params.put(
&format!("{}{}", prefix, "DesiredCapacity"),
&obj.desired_capacity.to_string(),
);
if let Some(ref field_value) = obj.honor_cooldown {
params.put(
&format!("{}{}", prefix, "HonorCooldown"),
&field_value.to_string(),
);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct SetInstanceHealthQuery {
pub health_status: String,
pub instance_id: String,
pub should_respect_grace_period: Option<bool>,
}
struct SetInstanceHealthQuerySerializer;
impl SetInstanceHealthQuerySerializer {
fn serialize(params: &mut Params, name: &str, obj: &SetInstanceHealthQuery) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(&format!("{}{}", prefix, "HealthStatus"), &obj.health_status);
params.put(&format!("{}{}", prefix, "InstanceId"), &obj.instance_id);
if let Some(ref field_value) = obj.should_respect_grace_period {
params.put(
&format!("{}{}", prefix, "ShouldRespectGracePeriod"),
&field_value.to_string(),
);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct SetInstanceProtectionAnswer {}
struct SetInstanceProtectionAnswerDeserializer;
impl SetInstanceProtectionAnswerDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<SetInstanceProtectionAnswer, XmlParseError> {
start_element(tag_name, stack)?;
let obj = SetInstanceProtectionAnswer::default();
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct SetInstanceProtectionQuery {
pub auto_scaling_group_name: String,
pub instance_ids: Vec<String>,
pub protected_from_scale_in: bool,
}
struct SetInstanceProtectionQuerySerializer;
impl SetInstanceProtectionQuerySerializer {
fn serialize(params: &mut Params, name: &str, obj: &SetInstanceProtectionQuery) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "AutoScalingGroupName"),
&obj.auto_scaling_group_name,
);
InstanceIdsSerializer::serialize(
params,
&format!("{}{}", prefix, "InstanceIds"),
&obj.instance_ids,
);
params.put(
&format!("{}{}", prefix, "ProtectedFromScaleIn"),
&obj.protected_from_scale_in.to_string(),
);
}
}
struct SpotInstancePoolsDeserializer;
impl SpotInstancePoolsDeserializer {
#[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 SpotPriceDeserializer;
impl SpotPriceDeserializer {
#[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 StepAdjustment {
pub metric_interval_lower_bound: Option<f64>,
pub metric_interval_upper_bound: Option<f64>,
pub scaling_adjustment: i64,
}
struct StepAdjustmentDeserializer;
impl StepAdjustmentDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<StepAdjustment, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = StepAdjustment::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[..] {
"MetricIntervalLowerBound" => {
obj.metric_interval_lower_bound =
Some(MetricScaleDeserializer::deserialize(
"MetricIntervalLowerBound",
stack,
)?);
}
"MetricIntervalUpperBound" => {
obj.metric_interval_upper_bound =
Some(MetricScaleDeserializer::deserialize(
"MetricIntervalUpperBound",
stack,
)?);
}
"ScalingAdjustment" => {
obj.scaling_adjustment =
PolicyIncrementDeserializer::deserialize("ScalingAdjustment", stack)?;
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct StepAdjustmentSerializer;
impl StepAdjustmentSerializer {
fn serialize(params: &mut Params, name: &str, obj: &StepAdjustment) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.metric_interval_lower_bound {
params.put(
&format!("{}{}", prefix, "MetricIntervalLowerBound"),
&field_value.to_string(),
);
}
if let Some(ref field_value) = obj.metric_interval_upper_bound {
params.put(
&format!("{}{}", prefix, "MetricIntervalUpperBound"),
&field_value.to_string(),
);
}
params.put(
&format!("{}{}", prefix, "ScalingAdjustment"),
&obj.scaling_adjustment.to_string(),
);
}
}
struct StepAdjustmentsDeserializer;
impl StepAdjustmentsDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<StepAdjustment>, 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(StepAdjustmentDeserializer::deserialize("member", stack)?);
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
end_element(tag_name, stack)?;
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
struct StepAdjustmentsSerializer;
impl StepAdjustmentsSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<StepAdjustment>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.member.{}", name, index + 1);
StepAdjustmentSerializer::serialize(params, &key, obj);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct SuspendedProcess {
pub process_name: Option<String>,
pub suspension_reason: Option<String>,
}
struct SuspendedProcessDeserializer;
impl SuspendedProcessDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<SuspendedProcess, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = SuspendedProcess::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[..] {
"ProcessName" => {
obj.process_name = Some(XmlStringMaxLen255Deserializer::deserialize(
"ProcessName",
stack,
)?);
}
"SuspensionReason" => {
obj.suspension_reason = Some(XmlStringMaxLen255Deserializer::deserialize(
"SuspensionReason",
stack,
)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct SuspendedProcessesDeserializer;
impl SuspendedProcessesDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<SuspendedProcess>, 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(SuspendedProcessDeserializer::deserialize("member", 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 Tag {
pub key: String,
pub propagate_at_launch: Option<bool>,
pub resource_id: Option<String>,
pub resource_type: Option<String>,
pub value: Option<String>,
}
struct TagSerializer;
impl TagSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Tag) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(&format!("{}{}", prefix, "Key"), &obj.key);
if let Some(ref field_value) = obj.propagate_at_launch {
params.put(
&format!("{}{}", prefix, "PropagateAtLaunch"),
&field_value.to_string(),
);
}
if let Some(ref field_value) = obj.resource_id {
params.put(&format!("{}{}", prefix, "ResourceId"), &field_value);
}
if let Some(ref field_value) = obj.resource_type {
params.put(&format!("{}{}", prefix, "ResourceType"), &field_value);
}
if let Some(ref field_value) = obj.value {
params.put(&format!("{}{}", prefix, "Value"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct TagDescription {
pub key: Option<String>,
pub propagate_at_launch: Option<bool>,
pub resource_id: Option<String>,
pub resource_type: Option<String>,
pub value: Option<String>,
}
struct TagDescriptionDeserializer;
impl TagDescriptionDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<TagDescription, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = TagDescription::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)?);
}
"PropagateAtLaunch" => {
obj.propagate_at_launch = Some(PropagateAtLaunchDeserializer::deserialize(
"PropagateAtLaunch",
stack,
)?);
}
"ResourceId" => {
obj.resource_id =
Some(XmlStringDeserializer::deserialize("ResourceId", stack)?);
}
"ResourceType" => {
obj.resource_type =
Some(XmlStringDeserializer::deserialize("ResourceType", 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)
}
}
struct TagDescriptionListDeserializer;
impl TagDescriptionListDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<TagDescription>, 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(TagDescriptionDeserializer::deserialize("member", stack)?);
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
end_element(tag_name, stack)?;
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
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)
}
}
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)
}
}
struct TagsSerializer;
impl TagsSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<Tag>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.member.{}", name, index + 1);
TagSerializer::serialize(params, &key, obj);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct TagsType {
pub next_token: Option<String>,
pub tags: Option<Vec<TagDescription>>,
}
struct TagsTypeDeserializer;
impl TagsTypeDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<TagsType, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = TagsType::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(XmlStringDeserializer::deserialize("NextToken", stack)?);
}
"Tags" => {
obj.tags = match obj.tags {
Some(ref mut existing) => {
existing.extend(TagDescriptionListDeserializer::deserialize(
"Tags", stack,
)?);
Some(existing.to_vec())
}
None => {
Some(TagDescriptionListDeserializer::deserialize("Tags", stack)?)
}
};
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct TargetGroupARNsDeserializer;
impl TargetGroupARNsDeserializer {
#[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(XmlStringMaxLen511Deserializer::deserialize(
"member", stack,
)?);
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
end_element(tag_name, stack)?;
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
struct TargetGroupARNsSerializer;
impl TargetGroupARNsSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.member.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct TargetTrackingConfiguration {
pub customized_metric_specification: Option<CustomizedMetricSpecification>,
pub disable_scale_in: Option<bool>,
pub predefined_metric_specification: Option<PredefinedMetricSpecification>,
pub target_value: f64,
}
struct TargetTrackingConfigurationDeserializer;
impl TargetTrackingConfigurationDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<TargetTrackingConfiguration, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = TargetTrackingConfiguration::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[..] {
"CustomizedMetricSpecification" => {
obj.customized_metric_specification =
Some(CustomizedMetricSpecificationDeserializer::deserialize(
"CustomizedMetricSpecification",
stack,
)?);
}
"DisableScaleIn" => {
obj.disable_scale_in = Some(DisableScaleInDeserializer::deserialize(
"DisableScaleIn",
stack,
)?);
}
"PredefinedMetricSpecification" => {
obj.predefined_metric_specification =
Some(PredefinedMetricSpecificationDeserializer::deserialize(
"PredefinedMetricSpecification",
stack,
)?);
}
"TargetValue" => {
obj.target_value =
MetricScaleDeserializer::deserialize("TargetValue", stack)?;
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct TargetTrackingConfigurationSerializer;
impl TargetTrackingConfigurationSerializer {
fn serialize(params: &mut Params, name: &str, obj: &TargetTrackingConfiguration) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.customized_metric_specification {
CustomizedMetricSpecificationSerializer::serialize(
params,
&format!("{}{}", prefix, "CustomizedMetricSpecification"),
field_value,
);
}
if let Some(ref field_value) = obj.disable_scale_in {
params.put(
&format!("{}{}", prefix, "DisableScaleIn"),
&field_value.to_string(),
);
}
if let Some(ref field_value) = obj.predefined_metric_specification {
PredefinedMetricSpecificationSerializer::serialize(
params,
&format!("{}{}", prefix, "PredefinedMetricSpecification"),
field_value,
);
}
params.put(
&format!("{}{}", prefix, "TargetValue"),
&obj.target_value.to_string(),
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct TerminateInstanceInAutoScalingGroupType {
pub instance_id: String,
pub should_decrement_desired_capacity: bool,
}
struct TerminateInstanceInAutoScalingGroupTypeSerializer;
impl TerminateInstanceInAutoScalingGroupTypeSerializer {
fn serialize(params: &mut Params, name: &str, obj: &TerminateInstanceInAutoScalingGroupType) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(&format!("{}{}", prefix, "InstanceId"), &obj.instance_id);
params.put(
&format!("{}{}", prefix, "ShouldDecrementDesiredCapacity"),
&obj.should_decrement_desired_capacity.to_string(),
);
}
}
struct TerminationPoliciesDeserializer;
impl TerminationPoliciesDeserializer {
#[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(XmlStringMaxLen1600Deserializer::deserialize(
"member", stack,
)?);
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
end_element(tag_name, stack)?;
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
struct TerminationPoliciesSerializer;
impl TerminationPoliciesSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.member.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
struct TimestampTypeDeserializer;
impl TimestampTypeDeserializer {
#[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 UpdateAutoScalingGroupType {
pub auto_scaling_group_name: String,
pub availability_zones: Option<Vec<String>>,
pub default_cooldown: Option<i64>,
pub desired_capacity: Option<i64>,
pub health_check_grace_period: Option<i64>,
pub health_check_type: Option<String>,
pub launch_configuration_name: Option<String>,
pub launch_template: Option<LaunchTemplateSpecification>,
pub max_size: Option<i64>,
pub min_size: Option<i64>,
pub mixed_instances_policy: Option<MixedInstancesPolicy>,
pub new_instances_protected_from_scale_in: Option<bool>,
pub placement_group: Option<String>,
pub service_linked_role_arn: Option<String>,
pub termination_policies: Option<Vec<String>>,
pub vpc_zone_identifier: Option<String>,
}
struct UpdateAutoScalingGroupTypeSerializer;
impl UpdateAutoScalingGroupTypeSerializer {
fn serialize(params: &mut Params, name: &str, obj: &UpdateAutoScalingGroupType) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "AutoScalingGroupName"),
&obj.auto_scaling_group_name,
);
if let Some(ref field_value) = obj.availability_zones {
AvailabilityZonesSerializer::serialize(
params,
&format!("{}{}", prefix, "AvailabilityZones"),
field_value,
);
}
if let Some(ref field_value) = obj.default_cooldown {
params.put(
&format!("{}{}", prefix, "DefaultCooldown"),
&field_value.to_string(),
);
}
if let Some(ref field_value) = obj.desired_capacity {
params.put(
&format!("{}{}", prefix, "DesiredCapacity"),
&field_value.to_string(),
);
}
if let Some(ref field_value) = obj.health_check_grace_period {
params.put(
&format!("{}{}", prefix, "HealthCheckGracePeriod"),
&field_value.to_string(),
);
}
if let Some(ref field_value) = obj.health_check_type {
params.put(&format!("{}{}", prefix, "HealthCheckType"), &field_value);
}
if let Some(ref field_value) = obj.launch_configuration_name {
params.put(
&format!("{}{}", prefix, "LaunchConfigurationName"),
&field_value,
);
}
if let Some(ref field_value) = obj.launch_template {
LaunchTemplateSpecificationSerializer::serialize(
params,
&format!("{}{}", prefix, "LaunchTemplate"),
field_value,
);
}
if let Some(ref field_value) = obj.max_size {
params.put(
&format!("{}{}", prefix, "MaxSize"),
&field_value.to_string(),
);
}
if let Some(ref field_value) = obj.min_size {
params.put(
&format!("{}{}", prefix, "MinSize"),
&field_value.to_string(),
);
}
if let Some(ref field_value) = obj.mixed_instances_policy {
MixedInstancesPolicySerializer::serialize(
params,
&format!("{}{}", prefix, "MixedInstancesPolicy"),
field_value,
);
}
if let Some(ref field_value) = obj.new_instances_protected_from_scale_in {
params.put(
&format!("{}{}", prefix, "NewInstancesProtectedFromScaleIn"),
&field_value.to_string(),
);
}
if let Some(ref field_value) = obj.placement_group {
params.put(&format!("{}{}", prefix, "PlacementGroup"), &field_value);
}
if let Some(ref field_value) = obj.service_linked_role_arn {
params.put(
&format!("{}{}", prefix, "ServiceLinkedRoleARN"),
&field_value,
);
}
if let Some(ref field_value) = obj.termination_policies {
TerminationPoliciesSerializer::serialize(
params,
&format!("{}{}", prefix, "TerminationPolicies"),
field_value,
);
}
if let Some(ref field_value) = obj.vpc_zone_identifier {
params.put(&format!("{}{}", prefix, "VPCZoneIdentifier"), &field_value);
}
}
}
struct ValuesSerializer;
impl ValuesSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.member.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
struct XmlStringDeserializer;
impl XmlStringDeserializer {
#[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 XmlStringMaxLen1023Deserializer;
impl XmlStringMaxLen1023Deserializer {
#[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 XmlStringMaxLen1600Deserializer;
impl XmlStringMaxLen1600Deserializer {
#[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 XmlStringMaxLen19Deserializer;
impl XmlStringMaxLen19Deserializer {
#[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 XmlStringMaxLen2047Deserializer;
impl XmlStringMaxLen2047Deserializer {
#[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 XmlStringMaxLen255Deserializer;
impl XmlStringMaxLen255Deserializer {
#[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 XmlStringMaxLen32Deserializer;
impl XmlStringMaxLen32Deserializer {
#[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 XmlStringMaxLen511Deserializer;
impl XmlStringMaxLen511Deserializer {
#[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 XmlStringMaxLen64Deserializer;
impl XmlStringMaxLen64Deserializer {
#[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 XmlStringUserDataDeserializer;
impl XmlStringUserDataDeserializer {
#[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(Debug, PartialEq)]
pub enum AttachInstancesError {
ResourceContentionFault(String),
ServiceLinkedRoleFailure(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl AttachInstancesError {
pub fn from_response(res: BufferedHttpResponse) -> AttachInstancesError {
{
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[..] {
"ResourceContention" => {
return AttachInstancesError::ResourceContentionFault(String::from(
parsed_error.message,
));
}
"ServiceLinkedRoleFailure" => {
return AttachInstancesError::ServiceLinkedRoleFailure(String::from(
parsed_error.message,
));
}
_ => {}
}
}
}
AttachInstancesError::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 AttachInstancesError {
fn from(err: XmlParseError) -> AttachInstancesError {
let XmlParseError(message) = err;
AttachInstancesError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for AttachInstancesError {
fn from(err: CredentialsError) -> AttachInstancesError {
AttachInstancesError::Credentials(err)
}
}
impl From<HttpDispatchError> for AttachInstancesError {
fn from(err: HttpDispatchError) -> AttachInstancesError {
AttachInstancesError::HttpDispatch(err)
}
}
impl From<io::Error> for AttachInstancesError {
fn from(err: io::Error) -> AttachInstancesError {
AttachInstancesError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for AttachInstancesError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for AttachInstancesError {
fn description(&self) -> &str {
match *self {
AttachInstancesError::ResourceContentionFault(ref cause) => cause,
AttachInstancesError::ServiceLinkedRoleFailure(ref cause) => cause,
AttachInstancesError::Validation(ref cause) => cause,
AttachInstancesError::Credentials(ref err) => err.description(),
AttachInstancesError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
AttachInstancesError::ParseError(ref cause) => cause,
AttachInstancesError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum AttachLoadBalancerTargetGroupsError {
ResourceContentionFault(String),
ServiceLinkedRoleFailure(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl AttachLoadBalancerTargetGroupsError {
pub fn from_response(res: BufferedHttpResponse) -> AttachLoadBalancerTargetGroupsError {
{
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[..] {
"ResourceContention" => {
return AttachLoadBalancerTargetGroupsError::ResourceContentionFault(
String::from(parsed_error.message),
);
}
"ServiceLinkedRoleFailure" => {
return AttachLoadBalancerTargetGroupsError::ServiceLinkedRoleFailure(
String::from(parsed_error.message),
);
}
_ => {}
}
}
}
AttachLoadBalancerTargetGroupsError::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 AttachLoadBalancerTargetGroupsError {
fn from(err: XmlParseError) -> AttachLoadBalancerTargetGroupsError {
let XmlParseError(message) = err;
AttachLoadBalancerTargetGroupsError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for AttachLoadBalancerTargetGroupsError {
fn from(err: CredentialsError) -> AttachLoadBalancerTargetGroupsError {
AttachLoadBalancerTargetGroupsError::Credentials(err)
}
}
impl From<HttpDispatchError> for AttachLoadBalancerTargetGroupsError {
fn from(err: HttpDispatchError) -> AttachLoadBalancerTargetGroupsError {
AttachLoadBalancerTargetGroupsError::HttpDispatch(err)
}
}
impl From<io::Error> for AttachLoadBalancerTargetGroupsError {
fn from(err: io::Error) -> AttachLoadBalancerTargetGroupsError {
AttachLoadBalancerTargetGroupsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for AttachLoadBalancerTargetGroupsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for AttachLoadBalancerTargetGroupsError {
fn description(&self) -> &str {
match *self {
AttachLoadBalancerTargetGroupsError::ResourceContentionFault(ref cause) => cause,
AttachLoadBalancerTargetGroupsError::ServiceLinkedRoleFailure(ref cause) => cause,
AttachLoadBalancerTargetGroupsError::Validation(ref cause) => cause,
AttachLoadBalancerTargetGroupsError::Credentials(ref err) => err.description(),
AttachLoadBalancerTargetGroupsError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
AttachLoadBalancerTargetGroupsError::ParseError(ref cause) => cause,
AttachLoadBalancerTargetGroupsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum AttachLoadBalancersError {
ResourceContentionFault(String),
ServiceLinkedRoleFailure(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl AttachLoadBalancersError {
pub fn from_response(res: BufferedHttpResponse) -> AttachLoadBalancersError {
{
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[..] {
"ResourceContention" => {
return AttachLoadBalancersError::ResourceContentionFault(String::from(
parsed_error.message,
));
}
"ServiceLinkedRoleFailure" => {
return AttachLoadBalancersError::ServiceLinkedRoleFailure(String::from(
parsed_error.message,
));
}
_ => {}
}
}
}
AttachLoadBalancersError::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 AttachLoadBalancersError {
fn from(err: XmlParseError) -> AttachLoadBalancersError {
let XmlParseError(message) = err;
AttachLoadBalancersError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for AttachLoadBalancersError {
fn from(err: CredentialsError) -> AttachLoadBalancersError {
AttachLoadBalancersError::Credentials(err)
}
}
impl From<HttpDispatchError> for AttachLoadBalancersError {
fn from(err: HttpDispatchError) -> AttachLoadBalancersError {
AttachLoadBalancersError::HttpDispatch(err)
}
}
impl From<io::Error> for AttachLoadBalancersError {
fn from(err: io::Error) -> AttachLoadBalancersError {
AttachLoadBalancersError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for AttachLoadBalancersError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for AttachLoadBalancersError {
fn description(&self) -> &str {
match *self {
AttachLoadBalancersError::ResourceContentionFault(ref cause) => cause,
AttachLoadBalancersError::ServiceLinkedRoleFailure(ref cause) => cause,
AttachLoadBalancersError::Validation(ref cause) => cause,
AttachLoadBalancersError::Credentials(ref err) => err.description(),
AttachLoadBalancersError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
AttachLoadBalancersError::ParseError(ref cause) => cause,
AttachLoadBalancersError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum BatchDeleteScheduledActionError {
ResourceContentionFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl BatchDeleteScheduledActionError {
pub fn from_response(res: BufferedHttpResponse) -> BatchDeleteScheduledActionError {
{
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[..] {
"ResourceContention" => {
return BatchDeleteScheduledActionError::ResourceContentionFault(
String::from(parsed_error.message),
);
}
_ => {}
}
}
}
BatchDeleteScheduledActionError::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 BatchDeleteScheduledActionError {
fn from(err: XmlParseError) -> BatchDeleteScheduledActionError {
let XmlParseError(message) = err;
BatchDeleteScheduledActionError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for BatchDeleteScheduledActionError {
fn from(err: CredentialsError) -> BatchDeleteScheduledActionError {
BatchDeleteScheduledActionError::Credentials(err)
}
}
impl From<HttpDispatchError> for BatchDeleteScheduledActionError {
fn from(err: HttpDispatchError) -> BatchDeleteScheduledActionError {
BatchDeleteScheduledActionError::HttpDispatch(err)
}
}
impl From<io::Error> for BatchDeleteScheduledActionError {
fn from(err: io::Error) -> BatchDeleteScheduledActionError {
BatchDeleteScheduledActionError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for BatchDeleteScheduledActionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for BatchDeleteScheduledActionError {
fn description(&self) -> &str {
match *self {
BatchDeleteScheduledActionError::ResourceContentionFault(ref cause) => cause,
BatchDeleteScheduledActionError::Validation(ref cause) => cause,
BatchDeleteScheduledActionError::Credentials(ref err) => err.description(),
BatchDeleteScheduledActionError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
BatchDeleteScheduledActionError::ParseError(ref cause) => cause,
BatchDeleteScheduledActionError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum BatchPutScheduledUpdateGroupActionError {
AlreadyExistsFault(String),
LimitExceededFault(String),
ResourceContentionFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl BatchPutScheduledUpdateGroupActionError {
pub fn from_response(res: BufferedHttpResponse) -> BatchPutScheduledUpdateGroupActionError {
{
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[..] {
"AlreadyExists" => {
return BatchPutScheduledUpdateGroupActionError::AlreadyExistsFault(
String::from(parsed_error.message),
);
}
"LimitExceeded" => {
return BatchPutScheduledUpdateGroupActionError::LimitExceededFault(
String::from(parsed_error.message),
);
}
"ResourceContention" => {
return BatchPutScheduledUpdateGroupActionError::ResourceContentionFault(
String::from(parsed_error.message),
);
}
_ => {}
}
}
}
BatchPutScheduledUpdateGroupActionError::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 BatchPutScheduledUpdateGroupActionError {
fn from(err: XmlParseError) -> BatchPutScheduledUpdateGroupActionError {
let XmlParseError(message) = err;
BatchPutScheduledUpdateGroupActionError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for BatchPutScheduledUpdateGroupActionError {
fn from(err: CredentialsError) -> BatchPutScheduledUpdateGroupActionError {
BatchPutScheduledUpdateGroupActionError::Credentials(err)
}
}
impl From<HttpDispatchError> for BatchPutScheduledUpdateGroupActionError {
fn from(err: HttpDispatchError) -> BatchPutScheduledUpdateGroupActionError {
BatchPutScheduledUpdateGroupActionError::HttpDispatch(err)
}
}
impl From<io::Error> for BatchPutScheduledUpdateGroupActionError {
fn from(err: io::Error) -> BatchPutScheduledUpdateGroupActionError {
BatchPutScheduledUpdateGroupActionError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for BatchPutScheduledUpdateGroupActionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for BatchPutScheduledUpdateGroupActionError {
fn description(&self) -> &str {
match *self {
BatchPutScheduledUpdateGroupActionError::AlreadyExistsFault(ref cause) => cause,
BatchPutScheduledUpdateGroupActionError::LimitExceededFault(ref cause) => cause,
BatchPutScheduledUpdateGroupActionError::ResourceContentionFault(ref cause) => cause,
BatchPutScheduledUpdateGroupActionError::Validation(ref cause) => cause,
BatchPutScheduledUpdateGroupActionError::Credentials(ref err) => err.description(),
BatchPutScheduledUpdateGroupActionError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
BatchPutScheduledUpdateGroupActionError::ParseError(ref cause) => cause,
BatchPutScheduledUpdateGroupActionError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum CompleteLifecycleActionError {
ResourceContentionFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CompleteLifecycleActionError {
pub fn from_response(res: BufferedHttpResponse) -> CompleteLifecycleActionError {
{
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[..] {
"ResourceContention" => {
return CompleteLifecycleActionError::ResourceContentionFault(String::from(
parsed_error.message,
));
}
_ => {}
}
}
}
CompleteLifecycleActionError::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 CompleteLifecycleActionError {
fn from(err: XmlParseError) -> CompleteLifecycleActionError {
let XmlParseError(message) = err;
CompleteLifecycleActionError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for CompleteLifecycleActionError {
fn from(err: CredentialsError) -> CompleteLifecycleActionError {
CompleteLifecycleActionError::Credentials(err)
}
}
impl From<HttpDispatchError> for CompleteLifecycleActionError {
fn from(err: HttpDispatchError) -> CompleteLifecycleActionError {
CompleteLifecycleActionError::HttpDispatch(err)
}
}
impl From<io::Error> for CompleteLifecycleActionError {
fn from(err: io::Error) -> CompleteLifecycleActionError {
CompleteLifecycleActionError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CompleteLifecycleActionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CompleteLifecycleActionError {
fn description(&self) -> &str {
match *self {
CompleteLifecycleActionError::ResourceContentionFault(ref cause) => cause,
CompleteLifecycleActionError::Validation(ref cause) => cause,
CompleteLifecycleActionError::Credentials(ref err) => err.description(),
CompleteLifecycleActionError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
CompleteLifecycleActionError::ParseError(ref cause) => cause,
CompleteLifecycleActionError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateAutoScalingGroupError {
AlreadyExistsFault(String),
LimitExceededFault(String),
ResourceContentionFault(String),
ServiceLinkedRoleFailure(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CreateAutoScalingGroupError {
pub fn from_response(res: BufferedHttpResponse) -> CreateAutoScalingGroupError {
{
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[..] {
"AlreadyExists" => {
return CreateAutoScalingGroupError::AlreadyExistsFault(String::from(
parsed_error.message,
));
}
"LimitExceeded" => {
return CreateAutoScalingGroupError::LimitExceededFault(String::from(
parsed_error.message,
));
}
"ResourceContention" => {
return CreateAutoScalingGroupError::ResourceContentionFault(String::from(
parsed_error.message,
));
}
"ServiceLinkedRoleFailure" => {
return CreateAutoScalingGroupError::ServiceLinkedRoleFailure(String::from(
parsed_error.message,
));
}
_ => {}
}
}
}
CreateAutoScalingGroupError::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 CreateAutoScalingGroupError {
fn from(err: XmlParseError) -> CreateAutoScalingGroupError {
let XmlParseError(message) = err;
CreateAutoScalingGroupError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for CreateAutoScalingGroupError {
fn from(err: CredentialsError) -> CreateAutoScalingGroupError {
CreateAutoScalingGroupError::Credentials(err)
}
}
impl From<HttpDispatchError> for CreateAutoScalingGroupError {
fn from(err: HttpDispatchError) -> CreateAutoScalingGroupError {
CreateAutoScalingGroupError::HttpDispatch(err)
}
}
impl From<io::Error> for CreateAutoScalingGroupError {
fn from(err: io::Error) -> CreateAutoScalingGroupError {
CreateAutoScalingGroupError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CreateAutoScalingGroupError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateAutoScalingGroupError {
fn description(&self) -> &str {
match *self {
CreateAutoScalingGroupError::AlreadyExistsFault(ref cause) => cause,
CreateAutoScalingGroupError::LimitExceededFault(ref cause) => cause,
CreateAutoScalingGroupError::ResourceContentionFault(ref cause) => cause,
CreateAutoScalingGroupError::ServiceLinkedRoleFailure(ref cause) => cause,
CreateAutoScalingGroupError::Validation(ref cause) => cause,
CreateAutoScalingGroupError::Credentials(ref err) => err.description(),
CreateAutoScalingGroupError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
CreateAutoScalingGroupError::ParseError(ref cause) => cause,
CreateAutoScalingGroupError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateLaunchConfigurationError {
AlreadyExistsFault(String),
LimitExceededFault(String),
ResourceContentionFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CreateLaunchConfigurationError {
pub fn from_response(res: BufferedHttpResponse) -> CreateLaunchConfigurationError {
{
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[..] {
"AlreadyExists" => {
return CreateLaunchConfigurationError::AlreadyExistsFault(String::from(
parsed_error.message,
));
}
"LimitExceeded" => {
return CreateLaunchConfigurationError::LimitExceededFault(String::from(
parsed_error.message,
));
}
"ResourceContention" => {
return CreateLaunchConfigurationError::ResourceContentionFault(
String::from(parsed_error.message),
);
}
_ => {}
}
}
}
CreateLaunchConfigurationError::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 CreateLaunchConfigurationError {
fn from(err: XmlParseError) -> CreateLaunchConfigurationError {
let XmlParseError(message) = err;
CreateLaunchConfigurationError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for CreateLaunchConfigurationError {
fn from(err: CredentialsError) -> CreateLaunchConfigurationError {
CreateLaunchConfigurationError::Credentials(err)
}
}
impl From<HttpDispatchError> for CreateLaunchConfigurationError {
fn from(err: HttpDispatchError) -> CreateLaunchConfigurationError {
CreateLaunchConfigurationError::HttpDispatch(err)
}
}
impl From<io::Error> for CreateLaunchConfigurationError {
fn from(err: io::Error) -> CreateLaunchConfigurationError {
CreateLaunchConfigurationError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CreateLaunchConfigurationError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateLaunchConfigurationError {
fn description(&self) -> &str {
match *self {
CreateLaunchConfigurationError::AlreadyExistsFault(ref cause) => cause,
CreateLaunchConfigurationError::LimitExceededFault(ref cause) => cause,
CreateLaunchConfigurationError::ResourceContentionFault(ref cause) => cause,
CreateLaunchConfigurationError::Validation(ref cause) => cause,
CreateLaunchConfigurationError::Credentials(ref err) => err.description(),
CreateLaunchConfigurationError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
CreateLaunchConfigurationError::ParseError(ref cause) => cause,
CreateLaunchConfigurationError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateOrUpdateTagsError {
AlreadyExistsFault(String),
LimitExceededFault(String),
ResourceContentionFault(String),
ResourceInUseFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CreateOrUpdateTagsError {
pub fn from_response(res: BufferedHttpResponse) -> CreateOrUpdateTagsError {
{
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[..] {
"AlreadyExists" => {
return CreateOrUpdateTagsError::AlreadyExistsFault(String::from(
parsed_error.message,
));
}
"LimitExceeded" => {
return CreateOrUpdateTagsError::LimitExceededFault(String::from(
parsed_error.message,
));
}
"ResourceContention" => {
return CreateOrUpdateTagsError::ResourceContentionFault(String::from(
parsed_error.message,
));
}
"ResourceInUse" => {
return CreateOrUpdateTagsError::ResourceInUseFault(String::from(
parsed_error.message,
));
}
_ => {}
}
}
}
CreateOrUpdateTagsError::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 CreateOrUpdateTagsError {
fn from(err: XmlParseError) -> CreateOrUpdateTagsError {
let XmlParseError(message) = err;
CreateOrUpdateTagsError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for CreateOrUpdateTagsError {
fn from(err: CredentialsError) -> CreateOrUpdateTagsError {
CreateOrUpdateTagsError::Credentials(err)
}
}
impl From<HttpDispatchError> for CreateOrUpdateTagsError {
fn from(err: HttpDispatchError) -> CreateOrUpdateTagsError {
CreateOrUpdateTagsError::HttpDispatch(err)
}
}
impl From<io::Error> for CreateOrUpdateTagsError {
fn from(err: io::Error) -> CreateOrUpdateTagsError {
CreateOrUpdateTagsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CreateOrUpdateTagsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateOrUpdateTagsError {
fn description(&self) -> &str {
match *self {
CreateOrUpdateTagsError::AlreadyExistsFault(ref cause) => cause,
CreateOrUpdateTagsError::LimitExceededFault(ref cause) => cause,
CreateOrUpdateTagsError::ResourceContentionFault(ref cause) => cause,
CreateOrUpdateTagsError::ResourceInUseFault(ref cause) => cause,
CreateOrUpdateTagsError::Validation(ref cause) => cause,
CreateOrUpdateTagsError::Credentials(ref err) => err.description(),
CreateOrUpdateTagsError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
CreateOrUpdateTagsError::ParseError(ref cause) => cause,
CreateOrUpdateTagsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteAutoScalingGroupError {
ResourceContentionFault(String),
ResourceInUseFault(String),
ScalingActivityInProgressFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DeleteAutoScalingGroupError {
pub fn from_response(res: BufferedHttpResponse) -> DeleteAutoScalingGroupError {
{
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[..] {
"ResourceContention" => {
return DeleteAutoScalingGroupError::ResourceContentionFault(String::from(
parsed_error.message,
));
}
"ResourceInUse" => {
return DeleteAutoScalingGroupError::ResourceInUseFault(String::from(
parsed_error.message,
));
}
"ScalingActivityInProgress" => {
return DeleteAutoScalingGroupError::ScalingActivityInProgressFault(
String::from(parsed_error.message),
);
}
_ => {}
}
}
}
DeleteAutoScalingGroupError::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 DeleteAutoScalingGroupError {
fn from(err: XmlParseError) -> DeleteAutoScalingGroupError {
let XmlParseError(message) = err;
DeleteAutoScalingGroupError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DeleteAutoScalingGroupError {
fn from(err: CredentialsError) -> DeleteAutoScalingGroupError {
DeleteAutoScalingGroupError::Credentials(err)
}
}
impl From<HttpDispatchError> for DeleteAutoScalingGroupError {
fn from(err: HttpDispatchError) -> DeleteAutoScalingGroupError {
DeleteAutoScalingGroupError::HttpDispatch(err)
}
}
impl From<io::Error> for DeleteAutoScalingGroupError {
fn from(err: io::Error) -> DeleteAutoScalingGroupError {
DeleteAutoScalingGroupError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DeleteAutoScalingGroupError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteAutoScalingGroupError {
fn description(&self) -> &str {
match *self {
DeleteAutoScalingGroupError::ResourceContentionFault(ref cause) => cause,
DeleteAutoScalingGroupError::ResourceInUseFault(ref cause) => cause,
DeleteAutoScalingGroupError::ScalingActivityInProgressFault(ref cause) => cause,
DeleteAutoScalingGroupError::Validation(ref cause) => cause,
DeleteAutoScalingGroupError::Credentials(ref err) => err.description(),
DeleteAutoScalingGroupError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DeleteAutoScalingGroupError::ParseError(ref cause) => cause,
DeleteAutoScalingGroupError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteLaunchConfigurationError {
ResourceContentionFault(String),
ResourceInUseFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DeleteLaunchConfigurationError {
pub fn from_response(res: BufferedHttpResponse) -> DeleteLaunchConfigurationError {
{
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[..] {
"ResourceContention" => {
return DeleteLaunchConfigurationError::ResourceContentionFault(
String::from(parsed_error.message),
);
}
"ResourceInUse" => {
return DeleteLaunchConfigurationError::ResourceInUseFault(String::from(
parsed_error.message,
));
}
_ => {}
}
}
}
DeleteLaunchConfigurationError::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 DeleteLaunchConfigurationError {
fn from(err: XmlParseError) -> DeleteLaunchConfigurationError {
let XmlParseError(message) = err;
DeleteLaunchConfigurationError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DeleteLaunchConfigurationError {
fn from(err: CredentialsError) -> DeleteLaunchConfigurationError {
DeleteLaunchConfigurationError::Credentials(err)
}
}
impl From<HttpDispatchError> for DeleteLaunchConfigurationError {
fn from(err: HttpDispatchError) -> DeleteLaunchConfigurationError {
DeleteLaunchConfigurationError::HttpDispatch(err)
}
}
impl From<io::Error> for DeleteLaunchConfigurationError {
fn from(err: io::Error) -> DeleteLaunchConfigurationError {
DeleteLaunchConfigurationError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DeleteLaunchConfigurationError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteLaunchConfigurationError {
fn description(&self) -> &str {
match *self {
DeleteLaunchConfigurationError::ResourceContentionFault(ref cause) => cause,
DeleteLaunchConfigurationError::ResourceInUseFault(ref cause) => cause,
DeleteLaunchConfigurationError::Validation(ref cause) => cause,
DeleteLaunchConfigurationError::Credentials(ref err) => err.description(),
DeleteLaunchConfigurationError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DeleteLaunchConfigurationError::ParseError(ref cause) => cause,
DeleteLaunchConfigurationError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteLifecycleHookError {
ResourceContentionFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DeleteLifecycleHookError {
pub fn from_response(res: BufferedHttpResponse) -> DeleteLifecycleHookError {
{
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[..] {
"ResourceContention" => {
return DeleteLifecycleHookError::ResourceContentionFault(String::from(
parsed_error.message,
));
}
_ => {}
}
}
}
DeleteLifecycleHookError::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 DeleteLifecycleHookError {
fn from(err: XmlParseError) -> DeleteLifecycleHookError {
let XmlParseError(message) = err;
DeleteLifecycleHookError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DeleteLifecycleHookError {
fn from(err: CredentialsError) -> DeleteLifecycleHookError {
DeleteLifecycleHookError::Credentials(err)
}
}
impl From<HttpDispatchError> for DeleteLifecycleHookError {
fn from(err: HttpDispatchError) -> DeleteLifecycleHookError {
DeleteLifecycleHookError::HttpDispatch(err)
}
}
impl From<io::Error> for DeleteLifecycleHookError {
fn from(err: io::Error) -> DeleteLifecycleHookError {
DeleteLifecycleHookError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DeleteLifecycleHookError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteLifecycleHookError {
fn description(&self) -> &str {
match *self {
DeleteLifecycleHookError::ResourceContentionFault(ref cause) => cause,
DeleteLifecycleHookError::Validation(ref cause) => cause,
DeleteLifecycleHookError::Credentials(ref err) => err.description(),
DeleteLifecycleHookError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DeleteLifecycleHookError::ParseError(ref cause) => cause,
DeleteLifecycleHookError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteNotificationConfigurationError {
ResourceContentionFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DeleteNotificationConfigurationError {
pub fn from_response(res: BufferedHttpResponse) -> DeleteNotificationConfigurationError {
{
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[..] {
"ResourceContention" => {
return DeleteNotificationConfigurationError::ResourceContentionFault(
String::from(parsed_error.message),
);
}
_ => {}
}
}
}
DeleteNotificationConfigurationError::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 DeleteNotificationConfigurationError {
fn from(err: XmlParseError) -> DeleteNotificationConfigurationError {
let XmlParseError(message) = err;
DeleteNotificationConfigurationError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DeleteNotificationConfigurationError {
fn from(err: CredentialsError) -> DeleteNotificationConfigurationError {
DeleteNotificationConfigurationError::Credentials(err)
}
}
impl From<HttpDispatchError> for DeleteNotificationConfigurationError {
fn from(err: HttpDispatchError) -> DeleteNotificationConfigurationError {
DeleteNotificationConfigurationError::HttpDispatch(err)
}
}
impl From<io::Error> for DeleteNotificationConfigurationError {
fn from(err: io::Error) -> DeleteNotificationConfigurationError {
DeleteNotificationConfigurationError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DeleteNotificationConfigurationError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteNotificationConfigurationError {
fn description(&self) -> &str {
match *self {
DeleteNotificationConfigurationError::ResourceContentionFault(ref cause) => cause,
DeleteNotificationConfigurationError::Validation(ref cause) => cause,
DeleteNotificationConfigurationError::Credentials(ref err) => err.description(),
DeleteNotificationConfigurationError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DeleteNotificationConfigurationError::ParseError(ref cause) => cause,
DeleteNotificationConfigurationError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DeletePolicyError {
ResourceContentionFault(String),
ServiceLinkedRoleFailure(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DeletePolicyError {
pub fn from_response(res: BufferedHttpResponse) -> DeletePolicyError {
{
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[..] {
"ResourceContention" => {
return DeletePolicyError::ResourceContentionFault(String::from(
parsed_error.message,
));
}
"ServiceLinkedRoleFailure" => {
return DeletePolicyError::ServiceLinkedRoleFailure(String::from(
parsed_error.message,
));
}
_ => {}
}
}
}
DeletePolicyError::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 DeletePolicyError {
fn from(err: XmlParseError) -> DeletePolicyError {
let XmlParseError(message) = err;
DeletePolicyError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DeletePolicyError {
fn from(err: CredentialsError) -> DeletePolicyError {
DeletePolicyError::Credentials(err)
}
}
impl From<HttpDispatchError> for DeletePolicyError {
fn from(err: HttpDispatchError) -> DeletePolicyError {
DeletePolicyError::HttpDispatch(err)
}
}
impl From<io::Error> for DeletePolicyError {
fn from(err: io::Error) -> DeletePolicyError {
DeletePolicyError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DeletePolicyError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeletePolicyError {
fn description(&self) -> &str {
match *self {
DeletePolicyError::ResourceContentionFault(ref cause) => cause,
DeletePolicyError::ServiceLinkedRoleFailure(ref cause) => cause,
DeletePolicyError::Validation(ref cause) => cause,
DeletePolicyError::Credentials(ref err) => err.description(),
DeletePolicyError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
DeletePolicyError::ParseError(ref cause) => cause,
DeletePolicyError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteScheduledActionError {
ResourceContentionFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DeleteScheduledActionError {
pub fn from_response(res: BufferedHttpResponse) -> DeleteScheduledActionError {
{
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[..] {
"ResourceContention" => {
return DeleteScheduledActionError::ResourceContentionFault(String::from(
parsed_error.message,
));
}
_ => {}
}
}
}
DeleteScheduledActionError::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 DeleteScheduledActionError {
fn from(err: XmlParseError) -> DeleteScheduledActionError {
let XmlParseError(message) = err;
DeleteScheduledActionError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DeleteScheduledActionError {
fn from(err: CredentialsError) -> DeleteScheduledActionError {
DeleteScheduledActionError::Credentials(err)
}
}
impl From<HttpDispatchError> for DeleteScheduledActionError {
fn from(err: HttpDispatchError) -> DeleteScheduledActionError {
DeleteScheduledActionError::HttpDispatch(err)
}
}
impl From<io::Error> for DeleteScheduledActionError {
fn from(err: io::Error) -> DeleteScheduledActionError {
DeleteScheduledActionError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DeleteScheduledActionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteScheduledActionError {
fn description(&self) -> &str {
match *self {
DeleteScheduledActionError::ResourceContentionFault(ref cause) => cause,
DeleteScheduledActionError::Validation(ref cause) => cause,
DeleteScheduledActionError::Credentials(ref err) => err.description(),
DeleteScheduledActionError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DeleteScheduledActionError::ParseError(ref cause) => cause,
DeleteScheduledActionError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteTagsError {
ResourceContentionFault(String),
ResourceInUseFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DeleteTagsError {
pub fn from_response(res: BufferedHttpResponse) -> DeleteTagsError {
{
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[..] {
"ResourceContention" => {
return DeleteTagsError::ResourceContentionFault(String::from(
parsed_error.message,
));
}
"ResourceInUse" => {
return DeleteTagsError::ResourceInUseFault(String::from(
parsed_error.message,
));
}
_ => {}
}
}
}
DeleteTagsError::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 DeleteTagsError {
fn from(err: XmlParseError) -> DeleteTagsError {
let XmlParseError(message) = err;
DeleteTagsError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DeleteTagsError {
fn from(err: CredentialsError) -> DeleteTagsError {
DeleteTagsError::Credentials(err)
}
}
impl From<HttpDispatchError> for DeleteTagsError {
fn from(err: HttpDispatchError) -> DeleteTagsError {
DeleteTagsError::HttpDispatch(err)
}
}
impl From<io::Error> for DeleteTagsError {
fn from(err: io::Error) -> DeleteTagsError {
DeleteTagsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DeleteTagsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteTagsError {
fn description(&self) -> &str {
match *self {
DeleteTagsError::ResourceContentionFault(ref cause) => cause,
DeleteTagsError::ResourceInUseFault(ref cause) => cause,
DeleteTagsError::Validation(ref cause) => cause,
DeleteTagsError::Credentials(ref err) => err.description(),
DeleteTagsError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
DeleteTagsError::ParseError(ref cause) => cause,
DeleteTagsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeAccountLimitsError {
ResourceContentionFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeAccountLimitsError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeAccountLimitsError {
{
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[..] {
"ResourceContention" => {
return DescribeAccountLimitsError::ResourceContentionFault(String::from(
parsed_error.message,
));
}
_ => {}
}
}
}
DescribeAccountLimitsError::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 DescribeAccountLimitsError {
fn from(err: XmlParseError) -> DescribeAccountLimitsError {
let XmlParseError(message) = err;
DescribeAccountLimitsError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DescribeAccountLimitsError {
fn from(err: CredentialsError) -> DescribeAccountLimitsError {
DescribeAccountLimitsError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeAccountLimitsError {
fn from(err: HttpDispatchError) -> DescribeAccountLimitsError {
DescribeAccountLimitsError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeAccountLimitsError {
fn from(err: io::Error) -> DescribeAccountLimitsError {
DescribeAccountLimitsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeAccountLimitsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeAccountLimitsError {
fn description(&self) -> &str {
match *self {
DescribeAccountLimitsError::ResourceContentionFault(ref cause) => cause,
DescribeAccountLimitsError::Validation(ref cause) => cause,
DescribeAccountLimitsError::Credentials(ref err) => err.description(),
DescribeAccountLimitsError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DescribeAccountLimitsError::ParseError(ref cause) => cause,
DescribeAccountLimitsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeAdjustmentTypesError {
ResourceContentionFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeAdjustmentTypesError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeAdjustmentTypesError {
{
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[..] {
"ResourceContention" => {
return DescribeAdjustmentTypesError::ResourceContentionFault(String::from(
parsed_error.message,
));
}
_ => {}
}
}
}
DescribeAdjustmentTypesError::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 DescribeAdjustmentTypesError {
fn from(err: XmlParseError) -> DescribeAdjustmentTypesError {
let XmlParseError(message) = err;
DescribeAdjustmentTypesError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DescribeAdjustmentTypesError {
fn from(err: CredentialsError) -> DescribeAdjustmentTypesError {
DescribeAdjustmentTypesError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeAdjustmentTypesError {
fn from(err: HttpDispatchError) -> DescribeAdjustmentTypesError {
DescribeAdjustmentTypesError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeAdjustmentTypesError {
fn from(err: io::Error) -> DescribeAdjustmentTypesError {
DescribeAdjustmentTypesError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeAdjustmentTypesError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeAdjustmentTypesError {
fn description(&self) -> &str {
match *self {
DescribeAdjustmentTypesError::ResourceContentionFault(ref cause) => cause,
DescribeAdjustmentTypesError::Validation(ref cause) => cause,
DescribeAdjustmentTypesError::Credentials(ref err) => err.description(),
DescribeAdjustmentTypesError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DescribeAdjustmentTypesError::ParseError(ref cause) => cause,
DescribeAdjustmentTypesError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeAutoScalingGroupsError {
InvalidNextToken(String),
ResourceContentionFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeAutoScalingGroupsError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeAutoScalingGroupsError {
{
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[..] {
"InvalidNextToken" => {
return DescribeAutoScalingGroupsError::InvalidNextToken(String::from(
parsed_error.message,
));
}
"ResourceContention" => {
return DescribeAutoScalingGroupsError::ResourceContentionFault(
String::from(parsed_error.message),
);
}
_ => {}
}
}
}
DescribeAutoScalingGroupsError::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 DescribeAutoScalingGroupsError {
fn from(err: XmlParseError) -> DescribeAutoScalingGroupsError {
let XmlParseError(message) = err;
DescribeAutoScalingGroupsError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DescribeAutoScalingGroupsError {
fn from(err: CredentialsError) -> DescribeAutoScalingGroupsError {
DescribeAutoScalingGroupsError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeAutoScalingGroupsError {
fn from(err: HttpDispatchError) -> DescribeAutoScalingGroupsError {
DescribeAutoScalingGroupsError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeAutoScalingGroupsError {
fn from(err: io::Error) -> DescribeAutoScalingGroupsError {
DescribeAutoScalingGroupsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeAutoScalingGroupsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeAutoScalingGroupsError {
fn description(&self) -> &str {
match *self {
DescribeAutoScalingGroupsError::InvalidNextToken(ref cause) => cause,
DescribeAutoScalingGroupsError::ResourceContentionFault(ref cause) => cause,
DescribeAutoScalingGroupsError::Validation(ref cause) => cause,
DescribeAutoScalingGroupsError::Credentials(ref err) => err.description(),
DescribeAutoScalingGroupsError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DescribeAutoScalingGroupsError::ParseError(ref cause) => cause,
DescribeAutoScalingGroupsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeAutoScalingInstancesError {
InvalidNextToken(String),
ResourceContentionFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeAutoScalingInstancesError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeAutoScalingInstancesError {
{
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[..] {
"InvalidNextToken" => {
return DescribeAutoScalingInstancesError::InvalidNextToken(String::from(
parsed_error.message,
));
}
"ResourceContention" => {
return DescribeAutoScalingInstancesError::ResourceContentionFault(
String::from(parsed_error.message),
);
}
_ => {}
}
}
}
DescribeAutoScalingInstancesError::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 DescribeAutoScalingInstancesError {
fn from(err: XmlParseError) -> DescribeAutoScalingInstancesError {
let XmlParseError(message) = err;
DescribeAutoScalingInstancesError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DescribeAutoScalingInstancesError {
fn from(err: CredentialsError) -> DescribeAutoScalingInstancesError {
DescribeAutoScalingInstancesError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeAutoScalingInstancesError {
fn from(err: HttpDispatchError) -> DescribeAutoScalingInstancesError {
DescribeAutoScalingInstancesError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeAutoScalingInstancesError {
fn from(err: io::Error) -> DescribeAutoScalingInstancesError {
DescribeAutoScalingInstancesError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeAutoScalingInstancesError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeAutoScalingInstancesError {
fn description(&self) -> &str {
match *self {
DescribeAutoScalingInstancesError::InvalidNextToken(ref cause) => cause,
DescribeAutoScalingInstancesError::ResourceContentionFault(ref cause) => cause,
DescribeAutoScalingInstancesError::Validation(ref cause) => cause,
DescribeAutoScalingInstancesError::Credentials(ref err) => err.description(),
DescribeAutoScalingInstancesError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DescribeAutoScalingInstancesError::ParseError(ref cause) => cause,
DescribeAutoScalingInstancesError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeAutoScalingNotificationTypesError {
ResourceContentionFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeAutoScalingNotificationTypesError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeAutoScalingNotificationTypesError {
{
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[..] {
"ResourceContention" => {
return DescribeAutoScalingNotificationTypesError::ResourceContentionFault(
String::from(parsed_error.message),
);
}
_ => {}
}
}
}
DescribeAutoScalingNotificationTypesError::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 DescribeAutoScalingNotificationTypesError {
fn from(err: XmlParseError) -> DescribeAutoScalingNotificationTypesError {
let XmlParseError(message) = err;
DescribeAutoScalingNotificationTypesError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DescribeAutoScalingNotificationTypesError {
fn from(err: CredentialsError) -> DescribeAutoScalingNotificationTypesError {
DescribeAutoScalingNotificationTypesError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeAutoScalingNotificationTypesError {
fn from(err: HttpDispatchError) -> DescribeAutoScalingNotificationTypesError {
DescribeAutoScalingNotificationTypesError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeAutoScalingNotificationTypesError {
fn from(err: io::Error) -> DescribeAutoScalingNotificationTypesError {
DescribeAutoScalingNotificationTypesError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeAutoScalingNotificationTypesError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeAutoScalingNotificationTypesError {
fn description(&self) -> &str {
match *self {
DescribeAutoScalingNotificationTypesError::ResourceContentionFault(ref cause) => cause,
DescribeAutoScalingNotificationTypesError::Validation(ref cause) => cause,
DescribeAutoScalingNotificationTypesError::Credentials(ref err) => err.description(),
DescribeAutoScalingNotificationTypesError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DescribeAutoScalingNotificationTypesError::ParseError(ref cause) => cause,
DescribeAutoScalingNotificationTypesError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeLaunchConfigurationsError {
InvalidNextToken(String),
ResourceContentionFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeLaunchConfigurationsError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeLaunchConfigurationsError {
{
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[..] {
"InvalidNextToken" => {
return DescribeLaunchConfigurationsError::InvalidNextToken(String::from(
parsed_error.message,
));
}
"ResourceContention" => {
return DescribeLaunchConfigurationsError::ResourceContentionFault(
String::from(parsed_error.message),
);
}
_ => {}
}
}
}
DescribeLaunchConfigurationsError::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 DescribeLaunchConfigurationsError {
fn from(err: XmlParseError) -> DescribeLaunchConfigurationsError {
let XmlParseError(message) = err;
DescribeLaunchConfigurationsError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DescribeLaunchConfigurationsError {
fn from(err: CredentialsError) -> DescribeLaunchConfigurationsError {
DescribeLaunchConfigurationsError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeLaunchConfigurationsError {
fn from(err: HttpDispatchError) -> DescribeLaunchConfigurationsError {
DescribeLaunchConfigurationsError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeLaunchConfigurationsError {
fn from(err: io::Error) -> DescribeLaunchConfigurationsError {
DescribeLaunchConfigurationsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeLaunchConfigurationsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeLaunchConfigurationsError {
fn description(&self) -> &str {
match *self {
DescribeLaunchConfigurationsError::InvalidNextToken(ref cause) => cause,
DescribeLaunchConfigurationsError::ResourceContentionFault(ref cause) => cause,
DescribeLaunchConfigurationsError::Validation(ref cause) => cause,
DescribeLaunchConfigurationsError::Credentials(ref err) => err.description(),
DescribeLaunchConfigurationsError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DescribeLaunchConfigurationsError::ParseError(ref cause) => cause,
DescribeLaunchConfigurationsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeLifecycleHookTypesError {
ResourceContentionFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeLifecycleHookTypesError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeLifecycleHookTypesError {
{
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[..] {
"ResourceContention" => {
return DescribeLifecycleHookTypesError::ResourceContentionFault(
String::from(parsed_error.message),
);
}
_ => {}
}
}
}
DescribeLifecycleHookTypesError::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 DescribeLifecycleHookTypesError {
fn from(err: XmlParseError) -> DescribeLifecycleHookTypesError {
let XmlParseError(message) = err;
DescribeLifecycleHookTypesError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DescribeLifecycleHookTypesError {
fn from(err: CredentialsError) -> DescribeLifecycleHookTypesError {
DescribeLifecycleHookTypesError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeLifecycleHookTypesError {
fn from(err: HttpDispatchError) -> DescribeLifecycleHookTypesError {
DescribeLifecycleHookTypesError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeLifecycleHookTypesError {
fn from(err: io::Error) -> DescribeLifecycleHookTypesError {
DescribeLifecycleHookTypesError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeLifecycleHookTypesError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeLifecycleHookTypesError {
fn description(&self) -> &str {
match *self {
DescribeLifecycleHookTypesError::ResourceContentionFault(ref cause) => cause,
DescribeLifecycleHookTypesError::Validation(ref cause) => cause,
DescribeLifecycleHookTypesError::Credentials(ref err) => err.description(),
DescribeLifecycleHookTypesError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DescribeLifecycleHookTypesError::ParseError(ref cause) => cause,
DescribeLifecycleHookTypesError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeLifecycleHooksError {
ResourceContentionFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeLifecycleHooksError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeLifecycleHooksError {
{
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[..] {
"ResourceContention" => {
return DescribeLifecycleHooksError::ResourceContentionFault(String::from(
parsed_error.message,
));
}
_ => {}
}
}
}
DescribeLifecycleHooksError::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 DescribeLifecycleHooksError {
fn from(err: XmlParseError) -> DescribeLifecycleHooksError {
let XmlParseError(message) = err;
DescribeLifecycleHooksError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DescribeLifecycleHooksError {
fn from(err: CredentialsError) -> DescribeLifecycleHooksError {
DescribeLifecycleHooksError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeLifecycleHooksError {
fn from(err: HttpDispatchError) -> DescribeLifecycleHooksError {
DescribeLifecycleHooksError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeLifecycleHooksError {
fn from(err: io::Error) -> DescribeLifecycleHooksError {
DescribeLifecycleHooksError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeLifecycleHooksError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeLifecycleHooksError {
fn description(&self) -> &str {
match *self {
DescribeLifecycleHooksError::ResourceContentionFault(ref cause) => cause,
DescribeLifecycleHooksError::Validation(ref cause) => cause,
DescribeLifecycleHooksError::Credentials(ref err) => err.description(),
DescribeLifecycleHooksError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DescribeLifecycleHooksError::ParseError(ref cause) => cause,
DescribeLifecycleHooksError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeLoadBalancerTargetGroupsError {
ResourceContentionFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeLoadBalancerTargetGroupsError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeLoadBalancerTargetGroupsError {
{
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[..] {
"ResourceContention" => {
return DescribeLoadBalancerTargetGroupsError::ResourceContentionFault(
String::from(parsed_error.message),
);
}
_ => {}
}
}
}
DescribeLoadBalancerTargetGroupsError::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 DescribeLoadBalancerTargetGroupsError {
fn from(err: XmlParseError) -> DescribeLoadBalancerTargetGroupsError {
let XmlParseError(message) = err;
DescribeLoadBalancerTargetGroupsError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DescribeLoadBalancerTargetGroupsError {
fn from(err: CredentialsError) -> DescribeLoadBalancerTargetGroupsError {
DescribeLoadBalancerTargetGroupsError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeLoadBalancerTargetGroupsError {
fn from(err: HttpDispatchError) -> DescribeLoadBalancerTargetGroupsError {
DescribeLoadBalancerTargetGroupsError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeLoadBalancerTargetGroupsError {
fn from(err: io::Error) -> DescribeLoadBalancerTargetGroupsError {
DescribeLoadBalancerTargetGroupsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeLoadBalancerTargetGroupsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeLoadBalancerTargetGroupsError {
fn description(&self) -> &str {
match *self {
DescribeLoadBalancerTargetGroupsError::ResourceContentionFault(ref cause) => cause,
DescribeLoadBalancerTargetGroupsError::Validation(ref cause) => cause,
DescribeLoadBalancerTargetGroupsError::Credentials(ref err) => err.description(),
DescribeLoadBalancerTargetGroupsError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DescribeLoadBalancerTargetGroupsError::ParseError(ref cause) => cause,
DescribeLoadBalancerTargetGroupsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeLoadBalancersError {
ResourceContentionFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeLoadBalancersError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeLoadBalancersError {
{
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[..] {
"ResourceContention" => {
return DescribeLoadBalancersError::ResourceContentionFault(String::from(
parsed_error.message,
));
}
_ => {}
}
}
}
DescribeLoadBalancersError::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 DescribeLoadBalancersError {
fn from(err: XmlParseError) -> DescribeLoadBalancersError {
let XmlParseError(message) = err;
DescribeLoadBalancersError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DescribeLoadBalancersError {
fn from(err: CredentialsError) -> DescribeLoadBalancersError {
DescribeLoadBalancersError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeLoadBalancersError {
fn from(err: HttpDispatchError) -> DescribeLoadBalancersError {
DescribeLoadBalancersError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeLoadBalancersError {
fn from(err: io::Error) -> DescribeLoadBalancersError {
DescribeLoadBalancersError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeLoadBalancersError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeLoadBalancersError {
fn description(&self) -> &str {
match *self {
DescribeLoadBalancersError::ResourceContentionFault(ref cause) => cause,
DescribeLoadBalancersError::Validation(ref cause) => cause,
DescribeLoadBalancersError::Credentials(ref err) => err.description(),
DescribeLoadBalancersError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DescribeLoadBalancersError::ParseError(ref cause) => cause,
DescribeLoadBalancersError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeMetricCollectionTypesError {
ResourceContentionFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeMetricCollectionTypesError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeMetricCollectionTypesError {
{
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[..] {
"ResourceContention" => {
return DescribeMetricCollectionTypesError::ResourceContentionFault(
String::from(parsed_error.message),
);
}
_ => {}
}
}
}
DescribeMetricCollectionTypesError::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 DescribeMetricCollectionTypesError {
fn from(err: XmlParseError) -> DescribeMetricCollectionTypesError {
let XmlParseError(message) = err;
DescribeMetricCollectionTypesError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DescribeMetricCollectionTypesError {
fn from(err: CredentialsError) -> DescribeMetricCollectionTypesError {
DescribeMetricCollectionTypesError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeMetricCollectionTypesError {
fn from(err: HttpDispatchError) -> DescribeMetricCollectionTypesError {
DescribeMetricCollectionTypesError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeMetricCollectionTypesError {
fn from(err: io::Error) -> DescribeMetricCollectionTypesError {
DescribeMetricCollectionTypesError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeMetricCollectionTypesError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeMetricCollectionTypesError {
fn description(&self) -> &str {
match *self {
DescribeMetricCollectionTypesError::ResourceContentionFault(ref cause) => cause,
DescribeMetricCollectionTypesError::Validation(ref cause) => cause,
DescribeMetricCollectionTypesError::Credentials(ref err) => err.description(),
DescribeMetricCollectionTypesError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DescribeMetricCollectionTypesError::ParseError(ref cause) => cause,
DescribeMetricCollectionTypesError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeNotificationConfigurationsError {
InvalidNextToken(String),
ResourceContentionFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeNotificationConfigurationsError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeNotificationConfigurationsError {
{
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[..] {
"InvalidNextToken" => {
return DescribeNotificationConfigurationsError::InvalidNextToken(
String::from(parsed_error.message),
);
}
"ResourceContention" => {
return DescribeNotificationConfigurationsError::ResourceContentionFault(
String::from(parsed_error.message),
);
}
_ => {}
}
}
}
DescribeNotificationConfigurationsError::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 DescribeNotificationConfigurationsError {
fn from(err: XmlParseError) -> DescribeNotificationConfigurationsError {
let XmlParseError(message) = err;
DescribeNotificationConfigurationsError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DescribeNotificationConfigurationsError {
fn from(err: CredentialsError) -> DescribeNotificationConfigurationsError {
DescribeNotificationConfigurationsError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeNotificationConfigurationsError {
fn from(err: HttpDispatchError) -> DescribeNotificationConfigurationsError {
DescribeNotificationConfigurationsError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeNotificationConfigurationsError {
fn from(err: io::Error) -> DescribeNotificationConfigurationsError {
DescribeNotificationConfigurationsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeNotificationConfigurationsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeNotificationConfigurationsError {
fn description(&self) -> &str {
match *self {
DescribeNotificationConfigurationsError::InvalidNextToken(ref cause) => cause,
DescribeNotificationConfigurationsError::ResourceContentionFault(ref cause) => cause,
DescribeNotificationConfigurationsError::Validation(ref cause) => cause,
DescribeNotificationConfigurationsError::Credentials(ref err) => err.description(),
DescribeNotificationConfigurationsError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DescribeNotificationConfigurationsError::ParseError(ref cause) => cause,
DescribeNotificationConfigurationsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribePoliciesError {
InvalidNextToken(String),
ResourceContentionFault(String),
ServiceLinkedRoleFailure(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribePoliciesError {
pub fn from_response(res: BufferedHttpResponse) -> DescribePoliciesError {
{
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[..] {
"InvalidNextToken" => {
return DescribePoliciesError::InvalidNextToken(String::from(
parsed_error.message,
));
}
"ResourceContention" => {
return DescribePoliciesError::ResourceContentionFault(String::from(
parsed_error.message,
));
}
"ServiceLinkedRoleFailure" => {
return DescribePoliciesError::ServiceLinkedRoleFailure(String::from(
parsed_error.message,
));
}
_ => {}
}
}
}
DescribePoliciesError::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 DescribePoliciesError {
fn from(err: XmlParseError) -> DescribePoliciesError {
let XmlParseError(message) = err;
DescribePoliciesError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DescribePoliciesError {
fn from(err: CredentialsError) -> DescribePoliciesError {
DescribePoliciesError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribePoliciesError {
fn from(err: HttpDispatchError) -> DescribePoliciesError {
DescribePoliciesError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribePoliciesError {
fn from(err: io::Error) -> DescribePoliciesError {
DescribePoliciesError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribePoliciesError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribePoliciesError {
fn description(&self) -> &str {
match *self {
DescribePoliciesError::InvalidNextToken(ref cause) => cause,
DescribePoliciesError::ResourceContentionFault(ref cause) => cause,
DescribePoliciesError::ServiceLinkedRoleFailure(ref cause) => cause,
DescribePoliciesError::Validation(ref cause) => cause,
DescribePoliciesError::Credentials(ref err) => err.description(),
DescribePoliciesError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
DescribePoliciesError::ParseError(ref cause) => cause,
DescribePoliciesError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeScalingActivitiesError {
InvalidNextToken(String),
ResourceContentionFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeScalingActivitiesError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeScalingActivitiesError {
{
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[..] {
"InvalidNextToken" => {
return DescribeScalingActivitiesError::InvalidNextToken(String::from(
parsed_error.message,
));
}
"ResourceContention" => {
return DescribeScalingActivitiesError::ResourceContentionFault(
String::from(parsed_error.message),
);
}
_ => {}
}
}
}
DescribeScalingActivitiesError::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 DescribeScalingActivitiesError {
fn from(err: XmlParseError) -> DescribeScalingActivitiesError {
let XmlParseError(message) = err;
DescribeScalingActivitiesError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DescribeScalingActivitiesError {
fn from(err: CredentialsError) -> DescribeScalingActivitiesError {
DescribeScalingActivitiesError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeScalingActivitiesError {
fn from(err: HttpDispatchError) -> DescribeScalingActivitiesError {
DescribeScalingActivitiesError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeScalingActivitiesError {
fn from(err: io::Error) -> DescribeScalingActivitiesError {
DescribeScalingActivitiesError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeScalingActivitiesError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeScalingActivitiesError {
fn description(&self) -> &str {
match *self {
DescribeScalingActivitiesError::InvalidNextToken(ref cause) => cause,
DescribeScalingActivitiesError::ResourceContentionFault(ref cause) => cause,
DescribeScalingActivitiesError::Validation(ref cause) => cause,
DescribeScalingActivitiesError::Credentials(ref err) => err.description(),
DescribeScalingActivitiesError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DescribeScalingActivitiesError::ParseError(ref cause) => cause,
DescribeScalingActivitiesError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeScalingProcessTypesError {
ResourceContentionFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeScalingProcessTypesError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeScalingProcessTypesError {
{
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[..] {
"ResourceContention" => {
return DescribeScalingProcessTypesError::ResourceContentionFault(
String::from(parsed_error.message),
);
}
_ => {}
}
}
}
DescribeScalingProcessTypesError::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 DescribeScalingProcessTypesError {
fn from(err: XmlParseError) -> DescribeScalingProcessTypesError {
let XmlParseError(message) = err;
DescribeScalingProcessTypesError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DescribeScalingProcessTypesError {
fn from(err: CredentialsError) -> DescribeScalingProcessTypesError {
DescribeScalingProcessTypesError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeScalingProcessTypesError {
fn from(err: HttpDispatchError) -> DescribeScalingProcessTypesError {
DescribeScalingProcessTypesError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeScalingProcessTypesError {
fn from(err: io::Error) -> DescribeScalingProcessTypesError {
DescribeScalingProcessTypesError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeScalingProcessTypesError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeScalingProcessTypesError {
fn description(&self) -> &str {
match *self {
DescribeScalingProcessTypesError::ResourceContentionFault(ref cause) => cause,
DescribeScalingProcessTypesError::Validation(ref cause) => cause,
DescribeScalingProcessTypesError::Credentials(ref err) => err.description(),
DescribeScalingProcessTypesError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DescribeScalingProcessTypesError::ParseError(ref cause) => cause,
DescribeScalingProcessTypesError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeScheduledActionsError {
InvalidNextToken(String),
ResourceContentionFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeScheduledActionsError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeScheduledActionsError {
{
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[..] {
"InvalidNextToken" => {
return DescribeScheduledActionsError::InvalidNextToken(String::from(
parsed_error.message,
));
}
"ResourceContention" => {
return DescribeScheduledActionsError::ResourceContentionFault(String::from(
parsed_error.message,
));
}
_ => {}
}
}
}
DescribeScheduledActionsError::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 DescribeScheduledActionsError {
fn from(err: XmlParseError) -> DescribeScheduledActionsError {
let XmlParseError(message) = err;
DescribeScheduledActionsError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DescribeScheduledActionsError {
fn from(err: CredentialsError) -> DescribeScheduledActionsError {
DescribeScheduledActionsError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeScheduledActionsError {
fn from(err: HttpDispatchError) -> DescribeScheduledActionsError {
DescribeScheduledActionsError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeScheduledActionsError {
fn from(err: io::Error) -> DescribeScheduledActionsError {
DescribeScheduledActionsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeScheduledActionsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeScheduledActionsError {
fn description(&self) -> &str {
match *self {
DescribeScheduledActionsError::InvalidNextToken(ref cause) => cause,
DescribeScheduledActionsError::ResourceContentionFault(ref cause) => cause,
DescribeScheduledActionsError::Validation(ref cause) => cause,
DescribeScheduledActionsError::Credentials(ref err) => err.description(),
DescribeScheduledActionsError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DescribeScheduledActionsError::ParseError(ref cause) => cause,
DescribeScheduledActionsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeTagsError {
InvalidNextToken(String),
ResourceContentionFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeTagsError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeTagsError {
{
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[..] {
"InvalidNextToken" => {
return DescribeTagsError::InvalidNextToken(String::from(
parsed_error.message,
));
}
"ResourceContention" => {
return DescribeTagsError::ResourceContentionFault(String::from(
parsed_error.message,
));
}
_ => {}
}
}
}
DescribeTagsError::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 DescribeTagsError {
fn from(err: XmlParseError) -> DescribeTagsError {
let XmlParseError(message) = err;
DescribeTagsError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DescribeTagsError {
fn from(err: CredentialsError) -> DescribeTagsError {
DescribeTagsError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeTagsError {
fn from(err: HttpDispatchError) -> DescribeTagsError {
DescribeTagsError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeTagsError {
fn from(err: io::Error) -> DescribeTagsError {
DescribeTagsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeTagsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeTagsError {
fn description(&self) -> &str {
match *self {
DescribeTagsError::InvalidNextToken(ref cause) => cause,
DescribeTagsError::ResourceContentionFault(ref cause) => cause,
DescribeTagsError::Validation(ref cause) => cause,
DescribeTagsError::Credentials(ref err) => err.description(),
DescribeTagsError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
DescribeTagsError::ParseError(ref cause) => cause,
DescribeTagsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeTerminationPolicyTypesError {
ResourceContentionFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeTerminationPolicyTypesError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeTerminationPolicyTypesError {
{
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[..] {
"ResourceContention" => {
return DescribeTerminationPolicyTypesError::ResourceContentionFault(
String::from(parsed_error.message),
);
}
_ => {}
}
}
}
DescribeTerminationPolicyTypesError::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 DescribeTerminationPolicyTypesError {
fn from(err: XmlParseError) -> DescribeTerminationPolicyTypesError {
let XmlParseError(message) = err;
DescribeTerminationPolicyTypesError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DescribeTerminationPolicyTypesError {
fn from(err: CredentialsError) -> DescribeTerminationPolicyTypesError {
DescribeTerminationPolicyTypesError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeTerminationPolicyTypesError {
fn from(err: HttpDispatchError) -> DescribeTerminationPolicyTypesError {
DescribeTerminationPolicyTypesError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeTerminationPolicyTypesError {
fn from(err: io::Error) -> DescribeTerminationPolicyTypesError {
DescribeTerminationPolicyTypesError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeTerminationPolicyTypesError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeTerminationPolicyTypesError {
fn description(&self) -> &str {
match *self {
DescribeTerminationPolicyTypesError::ResourceContentionFault(ref cause) => cause,
DescribeTerminationPolicyTypesError::Validation(ref cause) => cause,
DescribeTerminationPolicyTypesError::Credentials(ref err) => err.description(),
DescribeTerminationPolicyTypesError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DescribeTerminationPolicyTypesError::ParseError(ref cause) => cause,
DescribeTerminationPolicyTypesError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DetachInstancesError {
ResourceContentionFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DetachInstancesError {
pub fn from_response(res: BufferedHttpResponse) -> DetachInstancesError {
{
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[..] {
"ResourceContention" => {
return DetachInstancesError::ResourceContentionFault(String::from(
parsed_error.message,
));
}
_ => {}
}
}
}
DetachInstancesError::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 DetachInstancesError {
fn from(err: XmlParseError) -> DetachInstancesError {
let XmlParseError(message) = err;
DetachInstancesError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DetachInstancesError {
fn from(err: CredentialsError) -> DetachInstancesError {
DetachInstancesError::Credentials(err)
}
}
impl From<HttpDispatchError> for DetachInstancesError {
fn from(err: HttpDispatchError) -> DetachInstancesError {
DetachInstancesError::HttpDispatch(err)
}
}
impl From<io::Error> for DetachInstancesError {
fn from(err: io::Error) -> DetachInstancesError {
DetachInstancesError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DetachInstancesError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DetachInstancesError {
fn description(&self) -> &str {
match *self {
DetachInstancesError::ResourceContentionFault(ref cause) => cause,
DetachInstancesError::Validation(ref cause) => cause,
DetachInstancesError::Credentials(ref err) => err.description(),
DetachInstancesError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
DetachInstancesError::ParseError(ref cause) => cause,
DetachInstancesError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DetachLoadBalancerTargetGroupsError {
ResourceContentionFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DetachLoadBalancerTargetGroupsError {
pub fn from_response(res: BufferedHttpResponse) -> DetachLoadBalancerTargetGroupsError {
{
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[..] {
"ResourceContention" => {
return DetachLoadBalancerTargetGroupsError::ResourceContentionFault(
String::from(parsed_error.message),
);
}
_ => {}
}
}
}
DetachLoadBalancerTargetGroupsError::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 DetachLoadBalancerTargetGroupsError {
fn from(err: XmlParseError) -> DetachLoadBalancerTargetGroupsError {
let XmlParseError(message) = err;
DetachLoadBalancerTargetGroupsError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DetachLoadBalancerTargetGroupsError {
fn from(err: CredentialsError) -> DetachLoadBalancerTargetGroupsError {
DetachLoadBalancerTargetGroupsError::Credentials(err)
}
}
impl From<HttpDispatchError> for DetachLoadBalancerTargetGroupsError {
fn from(err: HttpDispatchError) -> DetachLoadBalancerTargetGroupsError {
DetachLoadBalancerTargetGroupsError::HttpDispatch(err)
}
}
impl From<io::Error> for DetachLoadBalancerTargetGroupsError {
fn from(err: io::Error) -> DetachLoadBalancerTargetGroupsError {
DetachLoadBalancerTargetGroupsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DetachLoadBalancerTargetGroupsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DetachLoadBalancerTargetGroupsError {
fn description(&self) -> &str {
match *self {
DetachLoadBalancerTargetGroupsError::ResourceContentionFault(ref cause) => cause,
DetachLoadBalancerTargetGroupsError::Validation(ref cause) => cause,
DetachLoadBalancerTargetGroupsError::Credentials(ref err) => err.description(),
DetachLoadBalancerTargetGroupsError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DetachLoadBalancerTargetGroupsError::ParseError(ref cause) => cause,
DetachLoadBalancerTargetGroupsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DetachLoadBalancersError {
ResourceContentionFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DetachLoadBalancersError {
pub fn from_response(res: BufferedHttpResponse) -> DetachLoadBalancersError {
{
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[..] {
"ResourceContention" => {
return DetachLoadBalancersError::ResourceContentionFault(String::from(
parsed_error.message,
));
}
_ => {}
}
}
}
DetachLoadBalancersError::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 DetachLoadBalancersError {
fn from(err: XmlParseError) -> DetachLoadBalancersError {
let XmlParseError(message) = err;
DetachLoadBalancersError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DetachLoadBalancersError {
fn from(err: CredentialsError) -> DetachLoadBalancersError {
DetachLoadBalancersError::Credentials(err)
}
}
impl From<HttpDispatchError> for DetachLoadBalancersError {
fn from(err: HttpDispatchError) -> DetachLoadBalancersError {
DetachLoadBalancersError::HttpDispatch(err)
}
}
impl From<io::Error> for DetachLoadBalancersError {
fn from(err: io::Error) -> DetachLoadBalancersError {
DetachLoadBalancersError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DetachLoadBalancersError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DetachLoadBalancersError {
fn description(&self) -> &str {
match *self {
DetachLoadBalancersError::ResourceContentionFault(ref cause) => cause,
DetachLoadBalancersError::Validation(ref cause) => cause,
DetachLoadBalancersError::Credentials(ref err) => err.description(),
DetachLoadBalancersError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DetachLoadBalancersError::ParseError(ref cause) => cause,
DetachLoadBalancersError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DisableMetricsCollectionError {
ResourceContentionFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DisableMetricsCollectionError {
pub fn from_response(res: BufferedHttpResponse) -> DisableMetricsCollectionError {
{
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[..] {
"ResourceContention" => {
return DisableMetricsCollectionError::ResourceContentionFault(String::from(
parsed_error.message,
));
}
_ => {}
}
}
}
DisableMetricsCollectionError::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 DisableMetricsCollectionError {
fn from(err: XmlParseError) -> DisableMetricsCollectionError {
let XmlParseError(message) = err;
DisableMetricsCollectionError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DisableMetricsCollectionError {
fn from(err: CredentialsError) -> DisableMetricsCollectionError {
DisableMetricsCollectionError::Credentials(err)
}
}
impl From<HttpDispatchError> for DisableMetricsCollectionError {
fn from(err: HttpDispatchError) -> DisableMetricsCollectionError {
DisableMetricsCollectionError::HttpDispatch(err)
}
}
impl From<io::Error> for DisableMetricsCollectionError {
fn from(err: io::Error) -> DisableMetricsCollectionError {
DisableMetricsCollectionError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DisableMetricsCollectionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DisableMetricsCollectionError {
fn description(&self) -> &str {
match *self {
DisableMetricsCollectionError::ResourceContentionFault(ref cause) => cause,
DisableMetricsCollectionError::Validation(ref cause) => cause,
DisableMetricsCollectionError::Credentials(ref err) => err.description(),
DisableMetricsCollectionError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DisableMetricsCollectionError::ParseError(ref cause) => cause,
DisableMetricsCollectionError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum EnableMetricsCollectionError {
ResourceContentionFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl EnableMetricsCollectionError {
pub fn from_response(res: BufferedHttpResponse) -> EnableMetricsCollectionError {
{
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[..] {
"ResourceContention" => {
return EnableMetricsCollectionError::ResourceContentionFault(String::from(
parsed_error.message,
));
}
_ => {}
}
}
}
EnableMetricsCollectionError::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 EnableMetricsCollectionError {
fn from(err: XmlParseError) -> EnableMetricsCollectionError {
let XmlParseError(message) = err;
EnableMetricsCollectionError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for EnableMetricsCollectionError {
fn from(err: CredentialsError) -> EnableMetricsCollectionError {
EnableMetricsCollectionError::Credentials(err)
}
}
impl From<HttpDispatchError> for EnableMetricsCollectionError {
fn from(err: HttpDispatchError) -> EnableMetricsCollectionError {
EnableMetricsCollectionError::HttpDispatch(err)
}
}
impl From<io::Error> for EnableMetricsCollectionError {
fn from(err: io::Error) -> EnableMetricsCollectionError {
EnableMetricsCollectionError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for EnableMetricsCollectionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for EnableMetricsCollectionError {
fn description(&self) -> &str {
match *self {
EnableMetricsCollectionError::ResourceContentionFault(ref cause) => cause,
EnableMetricsCollectionError::Validation(ref cause) => cause,
EnableMetricsCollectionError::Credentials(ref err) => err.description(),
EnableMetricsCollectionError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
EnableMetricsCollectionError::ParseError(ref cause) => cause,
EnableMetricsCollectionError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum EnterStandbyError {
ResourceContentionFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl EnterStandbyError {
pub fn from_response(res: BufferedHttpResponse) -> EnterStandbyError {
{
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[..] {
"ResourceContention" => {
return EnterStandbyError::ResourceContentionFault(String::from(
parsed_error.message,
));
}
_ => {}
}
}
}
EnterStandbyError::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 EnterStandbyError {
fn from(err: XmlParseError) -> EnterStandbyError {
let XmlParseError(message) = err;
EnterStandbyError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for EnterStandbyError {
fn from(err: CredentialsError) -> EnterStandbyError {
EnterStandbyError::Credentials(err)
}
}
impl From<HttpDispatchError> for EnterStandbyError {
fn from(err: HttpDispatchError) -> EnterStandbyError {
EnterStandbyError::HttpDispatch(err)
}
}
impl From<io::Error> for EnterStandbyError {
fn from(err: io::Error) -> EnterStandbyError {
EnterStandbyError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for EnterStandbyError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for EnterStandbyError {
fn description(&self) -> &str {
match *self {
EnterStandbyError::ResourceContentionFault(ref cause) => cause,
EnterStandbyError::Validation(ref cause) => cause,
EnterStandbyError::Credentials(ref err) => err.description(),
EnterStandbyError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
EnterStandbyError::ParseError(ref cause) => cause,
EnterStandbyError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ExecutePolicyError {
ResourceContentionFault(String),
ScalingActivityInProgressFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ExecutePolicyError {
pub fn from_response(res: BufferedHttpResponse) -> ExecutePolicyError {
{
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[..] {
"ResourceContention" => {
return ExecutePolicyError::ResourceContentionFault(String::from(
parsed_error.message,
));
}
"ScalingActivityInProgress" => {
return ExecutePolicyError::ScalingActivityInProgressFault(String::from(
parsed_error.message,
));
}
_ => {}
}
}
}
ExecutePolicyError::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 ExecutePolicyError {
fn from(err: XmlParseError) -> ExecutePolicyError {
let XmlParseError(message) = err;
ExecutePolicyError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for ExecutePolicyError {
fn from(err: CredentialsError) -> ExecutePolicyError {
ExecutePolicyError::Credentials(err)
}
}
impl From<HttpDispatchError> for ExecutePolicyError {
fn from(err: HttpDispatchError) -> ExecutePolicyError {
ExecutePolicyError::HttpDispatch(err)
}
}
impl From<io::Error> for ExecutePolicyError {
fn from(err: io::Error) -> ExecutePolicyError {
ExecutePolicyError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ExecutePolicyError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ExecutePolicyError {
fn description(&self) -> &str {
match *self {
ExecutePolicyError::ResourceContentionFault(ref cause) => cause,
ExecutePolicyError::ScalingActivityInProgressFault(ref cause) => cause,
ExecutePolicyError::Validation(ref cause) => cause,
ExecutePolicyError::Credentials(ref err) => err.description(),
ExecutePolicyError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
ExecutePolicyError::ParseError(ref cause) => cause,
ExecutePolicyError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ExitStandbyError {
ResourceContentionFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ExitStandbyError {
pub fn from_response(res: BufferedHttpResponse) -> ExitStandbyError {
{
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[..] {
"ResourceContention" => {
return ExitStandbyError::ResourceContentionFault(String::from(
parsed_error.message,
));
}
_ => {}
}
}
}
ExitStandbyError::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 ExitStandbyError {
fn from(err: XmlParseError) -> ExitStandbyError {
let XmlParseError(message) = err;
ExitStandbyError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for ExitStandbyError {
fn from(err: CredentialsError) -> ExitStandbyError {
ExitStandbyError::Credentials(err)
}
}
impl From<HttpDispatchError> for ExitStandbyError {
fn from(err: HttpDispatchError) -> ExitStandbyError {
ExitStandbyError::HttpDispatch(err)
}
}
impl From<io::Error> for ExitStandbyError {
fn from(err: io::Error) -> ExitStandbyError {
ExitStandbyError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ExitStandbyError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ExitStandbyError {
fn description(&self) -> &str {
match *self {
ExitStandbyError::ResourceContentionFault(ref cause) => cause,
ExitStandbyError::Validation(ref cause) => cause,
ExitStandbyError::Credentials(ref err) => err.description(),
ExitStandbyError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
ExitStandbyError::ParseError(ref cause) => cause,
ExitStandbyError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum PutLifecycleHookError {
LimitExceededFault(String),
ResourceContentionFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl PutLifecycleHookError {
pub fn from_response(res: BufferedHttpResponse) -> PutLifecycleHookError {
{
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[..] {
"LimitExceeded" => {
return PutLifecycleHookError::LimitExceededFault(String::from(
parsed_error.message,
));
}
"ResourceContention" => {
return PutLifecycleHookError::ResourceContentionFault(String::from(
parsed_error.message,
));
}
_ => {}
}
}
}
PutLifecycleHookError::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 PutLifecycleHookError {
fn from(err: XmlParseError) -> PutLifecycleHookError {
let XmlParseError(message) = err;
PutLifecycleHookError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for PutLifecycleHookError {
fn from(err: CredentialsError) -> PutLifecycleHookError {
PutLifecycleHookError::Credentials(err)
}
}
impl From<HttpDispatchError> for PutLifecycleHookError {
fn from(err: HttpDispatchError) -> PutLifecycleHookError {
PutLifecycleHookError::HttpDispatch(err)
}
}
impl From<io::Error> for PutLifecycleHookError {
fn from(err: io::Error) -> PutLifecycleHookError {
PutLifecycleHookError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for PutLifecycleHookError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for PutLifecycleHookError {
fn description(&self) -> &str {
match *self {
PutLifecycleHookError::LimitExceededFault(ref cause) => cause,
PutLifecycleHookError::ResourceContentionFault(ref cause) => cause,
PutLifecycleHookError::Validation(ref cause) => cause,
PutLifecycleHookError::Credentials(ref err) => err.description(),
PutLifecycleHookError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
PutLifecycleHookError::ParseError(ref cause) => cause,
PutLifecycleHookError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum PutNotificationConfigurationError {
LimitExceededFault(String),
ResourceContentionFault(String),
ServiceLinkedRoleFailure(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl PutNotificationConfigurationError {
pub fn from_response(res: BufferedHttpResponse) -> PutNotificationConfigurationError {
{
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[..] {
"LimitExceeded" => {
return PutNotificationConfigurationError::LimitExceededFault(String::from(
parsed_error.message,
));
}
"ResourceContention" => {
return PutNotificationConfigurationError::ResourceContentionFault(
String::from(parsed_error.message),
);
}
"ServiceLinkedRoleFailure" => {
return PutNotificationConfigurationError::ServiceLinkedRoleFailure(
String::from(parsed_error.message),
);
}
_ => {}
}
}
}
PutNotificationConfigurationError::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 PutNotificationConfigurationError {
fn from(err: XmlParseError) -> PutNotificationConfigurationError {
let XmlParseError(message) = err;
PutNotificationConfigurationError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for PutNotificationConfigurationError {
fn from(err: CredentialsError) -> PutNotificationConfigurationError {
PutNotificationConfigurationError::Credentials(err)
}
}
impl From<HttpDispatchError> for PutNotificationConfigurationError {
fn from(err: HttpDispatchError) -> PutNotificationConfigurationError {
PutNotificationConfigurationError::HttpDispatch(err)
}
}
impl From<io::Error> for PutNotificationConfigurationError {
fn from(err: io::Error) -> PutNotificationConfigurationError {
PutNotificationConfigurationError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for PutNotificationConfigurationError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for PutNotificationConfigurationError {
fn description(&self) -> &str {
match *self {
PutNotificationConfigurationError::LimitExceededFault(ref cause) => cause,
PutNotificationConfigurationError::ResourceContentionFault(ref cause) => cause,
PutNotificationConfigurationError::ServiceLinkedRoleFailure(ref cause) => cause,
PutNotificationConfigurationError::Validation(ref cause) => cause,
PutNotificationConfigurationError::Credentials(ref err) => err.description(),
PutNotificationConfigurationError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
PutNotificationConfigurationError::ParseError(ref cause) => cause,
PutNotificationConfigurationError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum PutScalingPolicyError {
LimitExceededFault(String),
ResourceContentionFault(String),
ServiceLinkedRoleFailure(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl PutScalingPolicyError {
pub fn from_response(res: BufferedHttpResponse) -> PutScalingPolicyError {
{
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[..] {
"LimitExceeded" => {
return PutScalingPolicyError::LimitExceededFault(String::from(
parsed_error.message,
));
}
"ResourceContention" => {
return PutScalingPolicyError::ResourceContentionFault(String::from(
parsed_error.message,
));
}
"ServiceLinkedRoleFailure" => {
return PutScalingPolicyError::ServiceLinkedRoleFailure(String::from(
parsed_error.message,
));
}
_ => {}
}
}
}
PutScalingPolicyError::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 PutScalingPolicyError {
fn from(err: XmlParseError) -> PutScalingPolicyError {
let XmlParseError(message) = err;
PutScalingPolicyError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for PutScalingPolicyError {
fn from(err: CredentialsError) -> PutScalingPolicyError {
PutScalingPolicyError::Credentials(err)
}
}
impl From<HttpDispatchError> for PutScalingPolicyError {
fn from(err: HttpDispatchError) -> PutScalingPolicyError {
PutScalingPolicyError::HttpDispatch(err)
}
}
impl From<io::Error> for PutScalingPolicyError {
fn from(err: io::Error) -> PutScalingPolicyError {
PutScalingPolicyError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for PutScalingPolicyError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for PutScalingPolicyError {
fn description(&self) -> &str {
match *self {
PutScalingPolicyError::LimitExceededFault(ref cause) => cause,
PutScalingPolicyError::ResourceContentionFault(ref cause) => cause,
PutScalingPolicyError::ServiceLinkedRoleFailure(ref cause) => cause,
PutScalingPolicyError::Validation(ref cause) => cause,
PutScalingPolicyError::Credentials(ref err) => err.description(),
PutScalingPolicyError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
PutScalingPolicyError::ParseError(ref cause) => cause,
PutScalingPolicyError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum PutScheduledUpdateGroupActionError {
AlreadyExistsFault(String),
LimitExceededFault(String),
ResourceContentionFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl PutScheduledUpdateGroupActionError {
pub fn from_response(res: BufferedHttpResponse) -> PutScheduledUpdateGroupActionError {
{
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[..] {
"AlreadyExists" => {
return PutScheduledUpdateGroupActionError::AlreadyExistsFault(String::from(
parsed_error.message,
));
}
"LimitExceeded" => {
return PutScheduledUpdateGroupActionError::LimitExceededFault(String::from(
parsed_error.message,
));
}
"ResourceContention" => {
return PutScheduledUpdateGroupActionError::ResourceContentionFault(
String::from(parsed_error.message),
);
}
_ => {}
}
}
}
PutScheduledUpdateGroupActionError::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 PutScheduledUpdateGroupActionError {
fn from(err: XmlParseError) -> PutScheduledUpdateGroupActionError {
let XmlParseError(message) = err;
PutScheduledUpdateGroupActionError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for PutScheduledUpdateGroupActionError {
fn from(err: CredentialsError) -> PutScheduledUpdateGroupActionError {
PutScheduledUpdateGroupActionError::Credentials(err)
}
}
impl From<HttpDispatchError> for PutScheduledUpdateGroupActionError {
fn from(err: HttpDispatchError) -> PutScheduledUpdateGroupActionError {
PutScheduledUpdateGroupActionError::HttpDispatch(err)
}
}
impl From<io::Error> for PutScheduledUpdateGroupActionError {
fn from(err: io::Error) -> PutScheduledUpdateGroupActionError {
PutScheduledUpdateGroupActionError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for PutScheduledUpdateGroupActionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for PutScheduledUpdateGroupActionError {
fn description(&self) -> &str {
match *self {
PutScheduledUpdateGroupActionError::AlreadyExistsFault(ref cause) => cause,
PutScheduledUpdateGroupActionError::LimitExceededFault(ref cause) => cause,
PutScheduledUpdateGroupActionError::ResourceContentionFault(ref cause) => cause,
PutScheduledUpdateGroupActionError::Validation(ref cause) => cause,
PutScheduledUpdateGroupActionError::Credentials(ref err) => err.description(),
PutScheduledUpdateGroupActionError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
PutScheduledUpdateGroupActionError::ParseError(ref cause) => cause,
PutScheduledUpdateGroupActionError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum RecordLifecycleActionHeartbeatError {
ResourceContentionFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl RecordLifecycleActionHeartbeatError {
pub fn from_response(res: BufferedHttpResponse) -> RecordLifecycleActionHeartbeatError {
{
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[..] {
"ResourceContention" => {
return RecordLifecycleActionHeartbeatError::ResourceContentionFault(
String::from(parsed_error.message),
);
}
_ => {}
}
}
}
RecordLifecycleActionHeartbeatError::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 RecordLifecycleActionHeartbeatError {
fn from(err: XmlParseError) -> RecordLifecycleActionHeartbeatError {
let XmlParseError(message) = err;
RecordLifecycleActionHeartbeatError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for RecordLifecycleActionHeartbeatError {
fn from(err: CredentialsError) -> RecordLifecycleActionHeartbeatError {
RecordLifecycleActionHeartbeatError::Credentials(err)
}
}
impl From<HttpDispatchError> for RecordLifecycleActionHeartbeatError {
fn from(err: HttpDispatchError) -> RecordLifecycleActionHeartbeatError {
RecordLifecycleActionHeartbeatError::HttpDispatch(err)
}
}
impl From<io::Error> for RecordLifecycleActionHeartbeatError {
fn from(err: io::Error) -> RecordLifecycleActionHeartbeatError {
RecordLifecycleActionHeartbeatError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for RecordLifecycleActionHeartbeatError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for RecordLifecycleActionHeartbeatError {
fn description(&self) -> &str {
match *self {
RecordLifecycleActionHeartbeatError::ResourceContentionFault(ref cause) => cause,
RecordLifecycleActionHeartbeatError::Validation(ref cause) => cause,
RecordLifecycleActionHeartbeatError::Credentials(ref err) => err.description(),
RecordLifecycleActionHeartbeatError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
RecordLifecycleActionHeartbeatError::ParseError(ref cause) => cause,
RecordLifecycleActionHeartbeatError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ResumeProcessesError {
ResourceContentionFault(String),
ResourceInUseFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ResumeProcessesError {
pub fn from_response(res: BufferedHttpResponse) -> ResumeProcessesError {
{
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[..] {
"ResourceContention" => {
return ResumeProcessesError::ResourceContentionFault(String::from(
parsed_error.message,
));
}
"ResourceInUse" => {
return ResumeProcessesError::ResourceInUseFault(String::from(
parsed_error.message,
));
}
_ => {}
}
}
}
ResumeProcessesError::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 ResumeProcessesError {
fn from(err: XmlParseError) -> ResumeProcessesError {
let XmlParseError(message) = err;
ResumeProcessesError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for ResumeProcessesError {
fn from(err: CredentialsError) -> ResumeProcessesError {
ResumeProcessesError::Credentials(err)
}
}
impl From<HttpDispatchError> for ResumeProcessesError {
fn from(err: HttpDispatchError) -> ResumeProcessesError {
ResumeProcessesError::HttpDispatch(err)
}
}
impl From<io::Error> for ResumeProcessesError {
fn from(err: io::Error) -> ResumeProcessesError {
ResumeProcessesError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ResumeProcessesError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ResumeProcessesError {
fn description(&self) -> &str {
match *self {
ResumeProcessesError::ResourceContentionFault(ref cause) => cause,
ResumeProcessesError::ResourceInUseFault(ref cause) => cause,
ResumeProcessesError::Validation(ref cause) => cause,
ResumeProcessesError::Credentials(ref err) => err.description(),
ResumeProcessesError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
ResumeProcessesError::ParseError(ref cause) => cause,
ResumeProcessesError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum SetDesiredCapacityError {
ResourceContentionFault(String),
ScalingActivityInProgressFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl SetDesiredCapacityError {
pub fn from_response(res: BufferedHttpResponse) -> SetDesiredCapacityError {
{
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[..] {
"ResourceContention" => {
return SetDesiredCapacityError::ResourceContentionFault(String::from(
parsed_error.message,
));
}
"ScalingActivityInProgress" => {
return SetDesiredCapacityError::ScalingActivityInProgressFault(
String::from(parsed_error.message),
);
}
_ => {}
}
}
}
SetDesiredCapacityError::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 SetDesiredCapacityError {
fn from(err: XmlParseError) -> SetDesiredCapacityError {
let XmlParseError(message) = err;
SetDesiredCapacityError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for SetDesiredCapacityError {
fn from(err: CredentialsError) -> SetDesiredCapacityError {
SetDesiredCapacityError::Credentials(err)
}
}
impl From<HttpDispatchError> for SetDesiredCapacityError {
fn from(err: HttpDispatchError) -> SetDesiredCapacityError {
SetDesiredCapacityError::HttpDispatch(err)
}
}
impl From<io::Error> for SetDesiredCapacityError {
fn from(err: io::Error) -> SetDesiredCapacityError {
SetDesiredCapacityError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for SetDesiredCapacityError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for SetDesiredCapacityError {
fn description(&self) -> &str {
match *self {
SetDesiredCapacityError::ResourceContentionFault(ref cause) => cause,
SetDesiredCapacityError::ScalingActivityInProgressFault(ref cause) => cause,
SetDesiredCapacityError::Validation(ref cause) => cause,
SetDesiredCapacityError::Credentials(ref err) => err.description(),
SetDesiredCapacityError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
SetDesiredCapacityError::ParseError(ref cause) => cause,
SetDesiredCapacityError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum SetInstanceHealthError {
ResourceContentionFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl SetInstanceHealthError {
pub fn from_response(res: BufferedHttpResponse) -> SetInstanceHealthError {
{
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[..] {
"ResourceContention" => {
return SetInstanceHealthError::ResourceContentionFault(String::from(
parsed_error.message,
));
}
_ => {}
}
}
}
SetInstanceHealthError::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 SetInstanceHealthError {
fn from(err: XmlParseError) -> SetInstanceHealthError {
let XmlParseError(message) = err;
SetInstanceHealthError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for SetInstanceHealthError {
fn from(err: CredentialsError) -> SetInstanceHealthError {
SetInstanceHealthError::Credentials(err)
}
}
impl From<HttpDispatchError> for SetInstanceHealthError {
fn from(err: HttpDispatchError) -> SetInstanceHealthError {
SetInstanceHealthError::HttpDispatch(err)
}
}
impl From<io::Error> for SetInstanceHealthError {
fn from(err: io::Error) -> SetInstanceHealthError {
SetInstanceHealthError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for SetInstanceHealthError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for SetInstanceHealthError {
fn description(&self) -> &str {
match *self {
SetInstanceHealthError::ResourceContentionFault(ref cause) => cause,
SetInstanceHealthError::Validation(ref cause) => cause,
SetInstanceHealthError::Credentials(ref err) => err.description(),
SetInstanceHealthError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
SetInstanceHealthError::ParseError(ref cause) => cause,
SetInstanceHealthError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum SetInstanceProtectionError {
LimitExceededFault(String),
ResourceContentionFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl SetInstanceProtectionError {
pub fn from_response(res: BufferedHttpResponse) -> SetInstanceProtectionError {
{
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[..] {
"LimitExceeded" => {
return SetInstanceProtectionError::LimitExceededFault(String::from(
parsed_error.message,
));
}
"ResourceContention" => {
return SetInstanceProtectionError::ResourceContentionFault(String::from(
parsed_error.message,
));
}
_ => {}
}
}
}
SetInstanceProtectionError::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 SetInstanceProtectionError {
fn from(err: XmlParseError) -> SetInstanceProtectionError {
let XmlParseError(message) = err;
SetInstanceProtectionError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for SetInstanceProtectionError {
fn from(err: CredentialsError) -> SetInstanceProtectionError {
SetInstanceProtectionError::Credentials(err)
}
}
impl From<HttpDispatchError> for SetInstanceProtectionError {
fn from(err: HttpDispatchError) -> SetInstanceProtectionError {
SetInstanceProtectionError::HttpDispatch(err)
}
}
impl From<io::Error> for SetInstanceProtectionError {
fn from(err: io::Error) -> SetInstanceProtectionError {
SetInstanceProtectionError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for SetInstanceProtectionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for SetInstanceProtectionError {
fn description(&self) -> &str {
match *self {
SetInstanceProtectionError::LimitExceededFault(ref cause) => cause,
SetInstanceProtectionError::ResourceContentionFault(ref cause) => cause,
SetInstanceProtectionError::Validation(ref cause) => cause,
SetInstanceProtectionError::Credentials(ref err) => err.description(),
SetInstanceProtectionError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
SetInstanceProtectionError::ParseError(ref cause) => cause,
SetInstanceProtectionError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum SuspendProcessesError {
ResourceContentionFault(String),
ResourceInUseFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl SuspendProcessesError {
pub fn from_response(res: BufferedHttpResponse) -> SuspendProcessesError {
{
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[..] {
"ResourceContention" => {
return SuspendProcessesError::ResourceContentionFault(String::from(
parsed_error.message,
));
}
"ResourceInUse" => {
return SuspendProcessesError::ResourceInUseFault(String::from(
parsed_error.message,
));
}
_ => {}
}
}
}
SuspendProcessesError::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 SuspendProcessesError {
fn from(err: XmlParseError) -> SuspendProcessesError {
let XmlParseError(message) = err;
SuspendProcessesError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for SuspendProcessesError {
fn from(err: CredentialsError) -> SuspendProcessesError {
SuspendProcessesError::Credentials(err)
}
}
impl From<HttpDispatchError> for SuspendProcessesError {
fn from(err: HttpDispatchError) -> SuspendProcessesError {
SuspendProcessesError::HttpDispatch(err)
}
}
impl From<io::Error> for SuspendProcessesError {
fn from(err: io::Error) -> SuspendProcessesError {
SuspendProcessesError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for SuspendProcessesError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for SuspendProcessesError {
fn description(&self) -> &str {
match *self {
SuspendProcessesError::ResourceContentionFault(ref cause) => cause,
SuspendProcessesError::ResourceInUseFault(ref cause) => cause,
SuspendProcessesError::Validation(ref cause) => cause,
SuspendProcessesError::Credentials(ref err) => err.description(),
SuspendProcessesError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
SuspendProcessesError::ParseError(ref cause) => cause,
SuspendProcessesError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum TerminateInstanceInAutoScalingGroupError {
ResourceContentionFault(String),
ScalingActivityInProgressFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl TerminateInstanceInAutoScalingGroupError {
pub fn from_response(res: BufferedHttpResponse) -> TerminateInstanceInAutoScalingGroupError {
{
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[..] {
"ResourceContention" => return TerminateInstanceInAutoScalingGroupError::ResourceContentionFault(String::from(parsed_error.message)),"ScalingActivityInProgress" => return TerminateInstanceInAutoScalingGroupError::ScalingActivityInProgressFault(String::from(parsed_error.message)),_ => {}
}
}
}
TerminateInstanceInAutoScalingGroupError::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 TerminateInstanceInAutoScalingGroupError {
fn from(err: XmlParseError) -> TerminateInstanceInAutoScalingGroupError {
let XmlParseError(message) = err;
TerminateInstanceInAutoScalingGroupError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for TerminateInstanceInAutoScalingGroupError {
fn from(err: CredentialsError) -> TerminateInstanceInAutoScalingGroupError {
TerminateInstanceInAutoScalingGroupError::Credentials(err)
}
}
impl From<HttpDispatchError> for TerminateInstanceInAutoScalingGroupError {
fn from(err: HttpDispatchError) -> TerminateInstanceInAutoScalingGroupError {
TerminateInstanceInAutoScalingGroupError::HttpDispatch(err)
}
}
impl From<io::Error> for TerminateInstanceInAutoScalingGroupError {
fn from(err: io::Error) -> TerminateInstanceInAutoScalingGroupError {
TerminateInstanceInAutoScalingGroupError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for TerminateInstanceInAutoScalingGroupError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for TerminateInstanceInAutoScalingGroupError {
fn description(&self) -> &str {
match *self {
TerminateInstanceInAutoScalingGroupError::ResourceContentionFault(ref cause) => cause,
TerminateInstanceInAutoScalingGroupError::ScalingActivityInProgressFault(ref cause) => {
cause
}
TerminateInstanceInAutoScalingGroupError::Validation(ref cause) => cause,
TerminateInstanceInAutoScalingGroupError::Credentials(ref err) => err.description(),
TerminateInstanceInAutoScalingGroupError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
TerminateInstanceInAutoScalingGroupError::ParseError(ref cause) => cause,
TerminateInstanceInAutoScalingGroupError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum UpdateAutoScalingGroupError {
ResourceContentionFault(String),
ScalingActivityInProgressFault(String),
ServiceLinkedRoleFailure(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl UpdateAutoScalingGroupError {
pub fn from_response(res: BufferedHttpResponse) -> UpdateAutoScalingGroupError {
{
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[..] {
"ResourceContention" => {
return UpdateAutoScalingGroupError::ResourceContentionFault(String::from(
parsed_error.message,
));
}
"ScalingActivityInProgress" => {
return UpdateAutoScalingGroupError::ScalingActivityInProgressFault(
String::from(parsed_error.message),
);
}
"ServiceLinkedRoleFailure" => {
return UpdateAutoScalingGroupError::ServiceLinkedRoleFailure(String::from(
parsed_error.message,
));
}
_ => {}
}
}
}
UpdateAutoScalingGroupError::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 UpdateAutoScalingGroupError {
fn from(err: XmlParseError) -> UpdateAutoScalingGroupError {
let XmlParseError(message) = err;
UpdateAutoScalingGroupError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for UpdateAutoScalingGroupError {
fn from(err: CredentialsError) -> UpdateAutoScalingGroupError {
UpdateAutoScalingGroupError::Credentials(err)
}
}
impl From<HttpDispatchError> for UpdateAutoScalingGroupError {
fn from(err: HttpDispatchError) -> UpdateAutoScalingGroupError {
UpdateAutoScalingGroupError::HttpDispatch(err)
}
}
impl From<io::Error> for UpdateAutoScalingGroupError {
fn from(err: io::Error) -> UpdateAutoScalingGroupError {
UpdateAutoScalingGroupError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for UpdateAutoScalingGroupError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for UpdateAutoScalingGroupError {
fn description(&self) -> &str {
match *self {
UpdateAutoScalingGroupError::ResourceContentionFault(ref cause) => cause,
UpdateAutoScalingGroupError::ScalingActivityInProgressFault(ref cause) => cause,
UpdateAutoScalingGroupError::ServiceLinkedRoleFailure(ref cause) => cause,
UpdateAutoScalingGroupError::Validation(ref cause) => cause,
UpdateAutoScalingGroupError::Credentials(ref err) => err.description(),
UpdateAutoScalingGroupError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
UpdateAutoScalingGroupError::ParseError(ref cause) => cause,
UpdateAutoScalingGroupError::Unknown(_) => "unknown error",
}
}
}
pub trait Autoscaling {
fn attach_instances(
&self,
input: AttachInstancesQuery,
) -> RusotoFuture<(), AttachInstancesError>;
fn attach_load_balancer_target_groups(
&self,
input: AttachLoadBalancerTargetGroupsType,
) -> RusotoFuture<AttachLoadBalancerTargetGroupsResultType, AttachLoadBalancerTargetGroupsError>;
fn attach_load_balancers(
&self,
input: AttachLoadBalancersType,
) -> RusotoFuture<AttachLoadBalancersResultType, AttachLoadBalancersError>;
fn batch_delete_scheduled_action(
&self,
input: BatchDeleteScheduledActionType,
) -> RusotoFuture<BatchDeleteScheduledActionAnswer, BatchDeleteScheduledActionError>;
fn batch_put_scheduled_update_group_action(
&self,
input: BatchPutScheduledUpdateGroupActionType,
) -> RusotoFuture<
BatchPutScheduledUpdateGroupActionAnswer,
BatchPutScheduledUpdateGroupActionError,
>;
fn complete_lifecycle_action(
&self,
input: CompleteLifecycleActionType,
) -> RusotoFuture<CompleteLifecycleActionAnswer, CompleteLifecycleActionError>;
fn create_auto_scaling_group(
&self,
input: CreateAutoScalingGroupType,
) -> RusotoFuture<(), CreateAutoScalingGroupError>;
fn create_launch_configuration(
&self,
input: CreateLaunchConfigurationType,
) -> RusotoFuture<(), CreateLaunchConfigurationError>;
fn create_or_update_tags(
&self,
input: CreateOrUpdateTagsType,
) -> RusotoFuture<(), CreateOrUpdateTagsError>;
fn delete_auto_scaling_group(
&self,
input: DeleteAutoScalingGroupType,
) -> RusotoFuture<(), DeleteAutoScalingGroupError>;
fn delete_launch_configuration(
&self,
input: LaunchConfigurationNameType,
) -> RusotoFuture<(), DeleteLaunchConfigurationError>;
fn delete_lifecycle_hook(
&self,
input: DeleteLifecycleHookType,
) -> RusotoFuture<DeleteLifecycleHookAnswer, DeleteLifecycleHookError>;
fn delete_notification_configuration(
&self,
input: DeleteNotificationConfigurationType,
) -> RusotoFuture<(), DeleteNotificationConfigurationError>;
fn delete_policy(&self, input: DeletePolicyType) -> RusotoFuture<(), DeletePolicyError>;
fn delete_scheduled_action(
&self,
input: DeleteScheduledActionType,
) -> RusotoFuture<(), DeleteScheduledActionError>;
fn delete_tags(&self, input: DeleteTagsType) -> RusotoFuture<(), DeleteTagsError>;
fn describe_account_limits(
&self,
) -> RusotoFuture<DescribeAccountLimitsAnswer, DescribeAccountLimitsError>;
fn describe_adjustment_types(
&self,
) -> RusotoFuture<DescribeAdjustmentTypesAnswer, DescribeAdjustmentTypesError>;
fn describe_auto_scaling_groups(
&self,
input: AutoScalingGroupNamesType,
) -> RusotoFuture<AutoScalingGroupsType, DescribeAutoScalingGroupsError>;
fn describe_auto_scaling_instances(
&self,
input: DescribeAutoScalingInstancesType,
) -> RusotoFuture<AutoScalingInstancesType, DescribeAutoScalingInstancesError>;
fn describe_auto_scaling_notification_types(
&self,
) -> RusotoFuture<
DescribeAutoScalingNotificationTypesAnswer,
DescribeAutoScalingNotificationTypesError,
>;
fn describe_launch_configurations(
&self,
input: LaunchConfigurationNamesType,
) -> RusotoFuture<LaunchConfigurationsType, DescribeLaunchConfigurationsError>;
fn describe_lifecycle_hook_types(
&self,
) -> RusotoFuture<DescribeLifecycleHookTypesAnswer, DescribeLifecycleHookTypesError>;
fn describe_lifecycle_hooks(
&self,
input: DescribeLifecycleHooksType,
) -> RusotoFuture<DescribeLifecycleHooksAnswer, DescribeLifecycleHooksError>;
fn describe_load_balancer_target_groups(
&self,
input: DescribeLoadBalancerTargetGroupsRequest,
) -> RusotoFuture<DescribeLoadBalancerTargetGroupsResponse, DescribeLoadBalancerTargetGroupsError>;
fn describe_load_balancers(
&self,
input: DescribeLoadBalancersRequest,
) -> RusotoFuture<DescribeLoadBalancersResponse, DescribeLoadBalancersError>;
fn describe_metric_collection_types(
&self,
) -> RusotoFuture<DescribeMetricCollectionTypesAnswer, DescribeMetricCollectionTypesError>;
fn describe_notification_configurations(
&self,
input: DescribeNotificationConfigurationsType,
) -> RusotoFuture<
DescribeNotificationConfigurationsAnswer,
DescribeNotificationConfigurationsError,
>;
fn describe_policies(
&self,
input: DescribePoliciesType,
) -> RusotoFuture<PoliciesType, DescribePoliciesError>;
fn describe_scaling_activities(
&self,
input: DescribeScalingActivitiesType,
) -> RusotoFuture<ActivitiesType, DescribeScalingActivitiesError>;
fn describe_scaling_process_types(
&self,
) -> RusotoFuture<ProcessesType, DescribeScalingProcessTypesError>;
fn describe_scheduled_actions(
&self,
input: DescribeScheduledActionsType,
) -> RusotoFuture<ScheduledActionsType, DescribeScheduledActionsError>;
fn describe_tags(&self, input: DescribeTagsType) -> RusotoFuture<TagsType, DescribeTagsError>;
fn describe_termination_policy_types(
&self,
) -> RusotoFuture<DescribeTerminationPolicyTypesAnswer, DescribeTerminationPolicyTypesError>;
fn detach_instances(
&self,
input: DetachInstancesQuery,
) -> RusotoFuture<DetachInstancesAnswer, DetachInstancesError>;
fn detach_load_balancer_target_groups(
&self,
input: DetachLoadBalancerTargetGroupsType,
) -> RusotoFuture<DetachLoadBalancerTargetGroupsResultType, DetachLoadBalancerTargetGroupsError>;
fn detach_load_balancers(
&self,
input: DetachLoadBalancersType,
) -> RusotoFuture<DetachLoadBalancersResultType, DetachLoadBalancersError>;
fn disable_metrics_collection(
&self,
input: DisableMetricsCollectionQuery,
) -> RusotoFuture<(), DisableMetricsCollectionError>;
fn enable_metrics_collection(
&self,
input: EnableMetricsCollectionQuery,
) -> RusotoFuture<(), EnableMetricsCollectionError>;
fn enter_standby(
&self,
input: EnterStandbyQuery,
) -> RusotoFuture<EnterStandbyAnswer, EnterStandbyError>;
fn execute_policy(&self, input: ExecutePolicyType) -> RusotoFuture<(), ExecutePolicyError>;
fn exit_standby(
&self,
input: ExitStandbyQuery,
) -> RusotoFuture<ExitStandbyAnswer, ExitStandbyError>;
fn put_lifecycle_hook(
&self,
input: PutLifecycleHookType,
) -> RusotoFuture<PutLifecycleHookAnswer, PutLifecycleHookError>;
fn put_notification_configuration(
&self,
input: PutNotificationConfigurationType,
) -> RusotoFuture<(), PutNotificationConfigurationError>;
fn put_scaling_policy(
&self,
input: PutScalingPolicyType,
) -> RusotoFuture<PolicyARNType, PutScalingPolicyError>;
fn put_scheduled_update_group_action(
&self,
input: PutScheduledUpdateGroupActionType,
) -> RusotoFuture<(), PutScheduledUpdateGroupActionError>;
fn record_lifecycle_action_heartbeat(
&self,
input: RecordLifecycleActionHeartbeatType,
) -> RusotoFuture<RecordLifecycleActionHeartbeatAnswer, RecordLifecycleActionHeartbeatError>;
fn resume_processes(
&self,
input: ScalingProcessQuery,
) -> RusotoFuture<(), ResumeProcessesError>;
fn set_desired_capacity(
&self,
input: SetDesiredCapacityType,
) -> RusotoFuture<(), SetDesiredCapacityError>;
fn set_instance_health(
&self,
input: SetInstanceHealthQuery,
) -> RusotoFuture<(), SetInstanceHealthError>;
fn set_instance_protection(
&self,
input: SetInstanceProtectionQuery,
) -> RusotoFuture<SetInstanceProtectionAnswer, SetInstanceProtectionError>;
fn suspend_processes(
&self,
input: ScalingProcessQuery,
) -> RusotoFuture<(), SuspendProcessesError>;
fn terminate_instance_in_auto_scaling_group(
&self,
input: TerminateInstanceInAutoScalingGroupType,
) -> RusotoFuture<ActivityType, TerminateInstanceInAutoScalingGroupError>;
fn update_auto_scaling_group(
&self,
input: UpdateAutoScalingGroupType,
) -> RusotoFuture<(), UpdateAutoScalingGroupError>;
}
#[derive(Clone)]
pub struct AutoscalingClient {
client: Client,
region: region::Region,
}
impl AutoscalingClient {
pub fn new(region: region::Region) -> AutoscalingClient {
AutoscalingClient {
client: Client::shared(),
region: region,
}
}
pub fn new_with<P, D>(
request_dispatcher: D,
credentials_provider: P,
region: region::Region,
) -> AutoscalingClient
where
P: ProvideAwsCredentials + Send + Sync + 'static,
P::Future: Send,
D: DispatchSignedRequest + Send + Sync + 'static,
D::Future: Send,
{
AutoscalingClient {
client: Client::new_with(credentials_provider, request_dispatcher),
region: region,
}
}
}
impl Autoscaling for AutoscalingClient {
fn attach_instances(
&self,
input: AttachInstancesQuery,
) -> RusotoFuture<(), AttachInstancesError> {
let mut request = SignedRequest::new("POST", "autoscaling", &self.region, "/");
let mut params = Params::new();
params.put("Action", "AttachInstances");
params.put("Version", "2011-01-01");
AttachInstancesQuerySerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(AttachInstancesError::from_response(response))),
);
}
Box::new(future::ok(::std::mem::drop(response)))
})
}
fn attach_load_balancer_target_groups(
&self,
input: AttachLoadBalancerTargetGroupsType,
) -> RusotoFuture<AttachLoadBalancerTargetGroupsResultType, AttachLoadBalancerTargetGroupsError>
{
let mut request = SignedRequest::new("POST", "autoscaling", &self.region, "/");
let mut params = Params::new();
params.put("Action", "AttachLoadBalancerTargetGroups");
params.put("Version", "2011-01-01");
AttachLoadBalancerTargetGroupsTypeSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(AttachLoadBalancerTargetGroupsError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = AttachLoadBalancerTargetGroupsResultType::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)?;
start_element(&actual_tag_name, &mut stack)?;
result = AttachLoadBalancerTargetGroupsResultTypeDeserializer::deserialize(
"AttachLoadBalancerTargetGroupsResult",
&mut stack,
)?;
skip_tree(&mut stack);
end_element(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn attach_load_balancers(
&self,
input: AttachLoadBalancersType,
) -> RusotoFuture<AttachLoadBalancersResultType, AttachLoadBalancersError> {
let mut request = SignedRequest::new("POST", "autoscaling", &self.region, "/");
let mut params = Params::new();
params.put("Action", "AttachLoadBalancers");
params.put("Version", "2011-01-01");
AttachLoadBalancersTypeSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response.buffer().from_err().and_then(|response| {
Err(AttachLoadBalancersError::from_response(response))
}),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = AttachLoadBalancersResultType::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)?;
start_element(&actual_tag_name, &mut stack)?;
result = AttachLoadBalancersResultTypeDeserializer::deserialize(
"AttachLoadBalancersResult",
&mut stack,
)?;
skip_tree(&mut stack);
end_element(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn batch_delete_scheduled_action(
&self,
input: BatchDeleteScheduledActionType,
) -> RusotoFuture<BatchDeleteScheduledActionAnswer, BatchDeleteScheduledActionError> {
let mut request = SignedRequest::new("POST", "autoscaling", &self.region, "/");
let mut params = Params::new();
params.put("Action", "BatchDeleteScheduledAction");
params.put("Version", "2011-01-01");
BatchDeleteScheduledActionTypeSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(BatchDeleteScheduledActionError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = BatchDeleteScheduledActionAnswer::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)?;
start_element(&actual_tag_name, &mut stack)?;
result = BatchDeleteScheduledActionAnswerDeserializer::deserialize(
"BatchDeleteScheduledActionResult",
&mut stack,
)?;
skip_tree(&mut stack);
end_element(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn batch_put_scheduled_update_group_action(
&self,
input: BatchPutScheduledUpdateGroupActionType,
) -> RusotoFuture<
BatchPutScheduledUpdateGroupActionAnswer,
BatchPutScheduledUpdateGroupActionError,
> {
let mut request = SignedRequest::new("POST", "autoscaling", &self.region, "/");
let mut params = Params::new();
params.put("Action", "BatchPutScheduledUpdateGroupAction");
params.put("Version", "2011-01-01");
BatchPutScheduledUpdateGroupActionTypeSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(BatchPutScheduledUpdateGroupActionError::from_response(
response,
))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = BatchPutScheduledUpdateGroupActionAnswer::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)?;
start_element(&actual_tag_name, &mut stack)?;
result = BatchPutScheduledUpdateGroupActionAnswerDeserializer::deserialize(
"BatchPutScheduledUpdateGroupActionResult",
&mut stack,
)?;
skip_tree(&mut stack);
end_element(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn complete_lifecycle_action(
&self,
input: CompleteLifecycleActionType,
) -> RusotoFuture<CompleteLifecycleActionAnswer, CompleteLifecycleActionError> {
let mut request = SignedRequest::new("POST", "autoscaling", &self.region, "/");
let mut params = Params::new();
params.put("Action", "CompleteLifecycleAction");
params.put("Version", "2011-01-01");
CompleteLifecycleActionTypeSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(CompleteLifecycleActionError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = CompleteLifecycleActionAnswer::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)?;
start_element(&actual_tag_name, &mut stack)?;
result = CompleteLifecycleActionAnswerDeserializer::deserialize(
"CompleteLifecycleActionResult",
&mut stack,
)?;
skip_tree(&mut stack);
end_element(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn create_auto_scaling_group(
&self,
input: CreateAutoScalingGroupType,
) -> RusotoFuture<(), CreateAutoScalingGroupError> {
let mut request = SignedRequest::new("POST", "autoscaling", &self.region, "/");
let mut params = Params::new();
params.put("Action", "CreateAutoScalingGroup");
params.put("Version", "2011-01-01");
CreateAutoScalingGroupTypeSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(CreateAutoScalingGroupError::from_response(response))
}));
}
Box::new(future::ok(::std::mem::drop(response)))
})
}
fn create_launch_configuration(
&self,
input: CreateLaunchConfigurationType,
) -> RusotoFuture<(), CreateLaunchConfigurationError> {
let mut request = SignedRequest::new("POST", "autoscaling", &self.region, "/");
let mut params = Params::new();
params.put("Action", "CreateLaunchConfiguration");
params.put("Version", "2011-01-01");
CreateLaunchConfigurationTypeSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(CreateLaunchConfigurationError::from_response(response))
}));
}
Box::new(future::ok(::std::mem::drop(response)))
})
}
fn create_or_update_tags(
&self,
input: CreateOrUpdateTagsType,
) -> RusotoFuture<(), CreateOrUpdateTagsError> {
let mut request = SignedRequest::new("POST", "autoscaling", &self.region, "/");
let mut params = Params::new();
params.put("Action", "CreateOrUpdateTags");
params.put("Version", "2011-01-01");
CreateOrUpdateTagsTypeSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(CreateOrUpdateTagsError::from_response(response))),
);
}
Box::new(future::ok(::std::mem::drop(response)))
})
}
fn delete_auto_scaling_group(
&self,
input: DeleteAutoScalingGroupType,
) -> RusotoFuture<(), DeleteAutoScalingGroupError> {
let mut request = SignedRequest::new("POST", "autoscaling", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DeleteAutoScalingGroup");
params.put("Version", "2011-01-01");
DeleteAutoScalingGroupTypeSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DeleteAutoScalingGroupError::from_response(response))
}));
}
Box::new(future::ok(::std::mem::drop(response)))
})
}
fn delete_launch_configuration(
&self,
input: LaunchConfigurationNameType,
) -> RusotoFuture<(), DeleteLaunchConfigurationError> {
let mut request = SignedRequest::new("POST", "autoscaling", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DeleteLaunchConfiguration");
params.put("Version", "2011-01-01");
LaunchConfigurationNameTypeSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DeleteLaunchConfigurationError::from_response(response))
}));
}
Box::new(future::ok(::std::mem::drop(response)))
})
}
fn delete_lifecycle_hook(
&self,
input: DeleteLifecycleHookType,
) -> RusotoFuture<DeleteLifecycleHookAnswer, DeleteLifecycleHookError> {
let mut request = SignedRequest::new("POST", "autoscaling", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DeleteLifecycleHook");
params.put("Version", "2011-01-01");
DeleteLifecycleHookTypeSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response.buffer().from_err().and_then(|response| {
Err(DeleteLifecycleHookError::from_response(response))
}),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DeleteLifecycleHookAnswer::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)?;
start_element(&actual_tag_name, &mut stack)?;
result = DeleteLifecycleHookAnswerDeserializer::deserialize(
"DeleteLifecycleHookResult",
&mut stack,
)?;
skip_tree(&mut stack);
end_element(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn delete_notification_configuration(
&self,
input: DeleteNotificationConfigurationType,
) -> RusotoFuture<(), DeleteNotificationConfigurationError> {
let mut request = SignedRequest::new("POST", "autoscaling", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DeleteNotificationConfiguration");
params.put("Version", "2011-01-01");
DeleteNotificationConfigurationTypeSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DeleteNotificationConfigurationError::from_response(
response,
))
}));
}
Box::new(future::ok(::std::mem::drop(response)))
})
}
fn delete_policy(&self, input: DeletePolicyType) -> RusotoFuture<(), DeletePolicyError> {
let mut request = SignedRequest::new("POST", "autoscaling", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DeletePolicy");
params.put("Version", "2011-01-01");
DeletePolicyTypeSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DeletePolicyError::from_response(response))),
);
}
Box::new(future::ok(::std::mem::drop(response)))
})
}
fn delete_scheduled_action(
&self,
input: DeleteScheduledActionType,
) -> RusotoFuture<(), DeleteScheduledActionError> {
let mut request = SignedRequest::new("POST", "autoscaling", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DeleteScheduledAction");
params.put("Version", "2011-01-01");
DeleteScheduledActionTypeSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response.buffer().from_err().and_then(|response| {
Err(DeleteScheduledActionError::from_response(response))
}),
);
}
Box::new(future::ok(::std::mem::drop(response)))
})
}
fn delete_tags(&self, input: DeleteTagsType) -> RusotoFuture<(), DeleteTagsError> {
let mut request = SignedRequest::new("POST", "autoscaling", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DeleteTags");
params.put("Version", "2011-01-01");
DeleteTagsTypeSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DeleteTagsError::from_response(response))),
);
}
Box::new(future::ok(::std::mem::drop(response)))
})
}
fn describe_account_limits(
&self,
) -> RusotoFuture<DescribeAccountLimitsAnswer, DescribeAccountLimitsError> {
let mut request = SignedRequest::new("POST", "autoscaling", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeAccountLimits");
params.put("Version", "2011-01-01");
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response.buffer().from_err().and_then(|response| {
Err(DescribeAccountLimitsError::from_response(response))
}),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeAccountLimitsAnswer::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)?;
start_element(&actual_tag_name, &mut stack)?;
result = DescribeAccountLimitsAnswerDeserializer::deserialize(
"DescribeAccountLimitsResult",
&mut stack,
)?;
skip_tree(&mut stack);
end_element(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn describe_adjustment_types(
&self,
) -> RusotoFuture<DescribeAdjustmentTypesAnswer, DescribeAdjustmentTypesError> {
let mut request = SignedRequest::new("POST", "autoscaling", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeAdjustmentTypes");
params.put("Version", "2011-01-01");
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeAdjustmentTypesError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeAdjustmentTypesAnswer::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)?;
start_element(&actual_tag_name, &mut stack)?;
result = DescribeAdjustmentTypesAnswerDeserializer::deserialize(
"DescribeAdjustmentTypesResult",
&mut stack,
)?;
skip_tree(&mut stack);
end_element(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn describe_auto_scaling_groups(
&self,
input: AutoScalingGroupNamesType,
) -> RusotoFuture<AutoScalingGroupsType, DescribeAutoScalingGroupsError> {
let mut request = SignedRequest::new("POST", "autoscaling", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeAutoScalingGroups");
params.put("Version", "2011-01-01");
AutoScalingGroupNamesTypeSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeAutoScalingGroupsError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = AutoScalingGroupsType::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)?;
start_element(&actual_tag_name, &mut stack)?;
result = AutoScalingGroupsTypeDeserializer::deserialize(
"DescribeAutoScalingGroupsResult",
&mut stack,
)?;
skip_tree(&mut stack);
end_element(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn describe_auto_scaling_instances(
&self,
input: DescribeAutoScalingInstancesType,
) -> RusotoFuture<AutoScalingInstancesType, DescribeAutoScalingInstancesError> {
let mut request = SignedRequest::new("POST", "autoscaling", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeAutoScalingInstances");
params.put("Version", "2011-01-01");
DescribeAutoScalingInstancesTypeSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeAutoScalingInstancesError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = AutoScalingInstancesType::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)?;
start_element(&actual_tag_name, &mut stack)?;
result = AutoScalingInstancesTypeDeserializer::deserialize(
"DescribeAutoScalingInstancesResult",
&mut stack,
)?;
skip_tree(&mut stack);
end_element(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn describe_auto_scaling_notification_types(
&self,
) -> RusotoFuture<
DescribeAutoScalingNotificationTypesAnswer,
DescribeAutoScalingNotificationTypesError,
> {
let mut request = SignedRequest::new("POST", "autoscaling", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeAutoScalingNotificationTypes");
params.put("Version", "2011-01-01");
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeAutoScalingNotificationTypesError::from_response(
response,
))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeAutoScalingNotificationTypesAnswer::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)?;
start_element(&actual_tag_name, &mut stack)?;
result = DescribeAutoScalingNotificationTypesAnswerDeserializer::deserialize(
"DescribeAutoScalingNotificationTypesResult",
&mut stack,
)?;
skip_tree(&mut stack);
end_element(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn describe_launch_configurations(
&self,
input: LaunchConfigurationNamesType,
) -> RusotoFuture<LaunchConfigurationsType, DescribeLaunchConfigurationsError> {
let mut request = SignedRequest::new("POST", "autoscaling", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeLaunchConfigurations");
params.put("Version", "2011-01-01");
LaunchConfigurationNamesTypeSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeLaunchConfigurationsError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = LaunchConfigurationsType::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)?;
start_element(&actual_tag_name, &mut stack)?;
result = LaunchConfigurationsTypeDeserializer::deserialize(
"DescribeLaunchConfigurationsResult",
&mut stack,
)?;
skip_tree(&mut stack);
end_element(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn describe_lifecycle_hook_types(
&self,
) -> RusotoFuture<DescribeLifecycleHookTypesAnswer, DescribeLifecycleHookTypesError> {
let mut request = SignedRequest::new("POST", "autoscaling", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeLifecycleHookTypes");
params.put("Version", "2011-01-01");
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeLifecycleHookTypesError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeLifecycleHookTypesAnswer::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)?;
start_element(&actual_tag_name, &mut stack)?;
result = DescribeLifecycleHookTypesAnswerDeserializer::deserialize(
"DescribeLifecycleHookTypesResult",
&mut stack,
)?;
skip_tree(&mut stack);
end_element(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn describe_lifecycle_hooks(
&self,
input: DescribeLifecycleHooksType,
) -> RusotoFuture<DescribeLifecycleHooksAnswer, DescribeLifecycleHooksError> {
let mut request = SignedRequest::new("POST", "autoscaling", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeLifecycleHooks");
params.put("Version", "2011-01-01");
DescribeLifecycleHooksTypeSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeLifecycleHooksError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeLifecycleHooksAnswer::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)?;
start_element(&actual_tag_name, &mut stack)?;
result = DescribeLifecycleHooksAnswerDeserializer::deserialize(
"DescribeLifecycleHooksResult",
&mut stack,
)?;
skip_tree(&mut stack);
end_element(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn describe_load_balancer_target_groups(
&self,
input: DescribeLoadBalancerTargetGroupsRequest,
) -> RusotoFuture<DescribeLoadBalancerTargetGroupsResponse, DescribeLoadBalancerTargetGroupsError>
{
let mut request = SignedRequest::new("POST", "autoscaling", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeLoadBalancerTargetGroups");
params.put("Version", "2011-01-01");
DescribeLoadBalancerTargetGroupsRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeLoadBalancerTargetGroupsError::from_response(
response,
))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeLoadBalancerTargetGroupsResponse::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)?;
start_element(&actual_tag_name, &mut stack)?;
result = DescribeLoadBalancerTargetGroupsResponseDeserializer::deserialize(
"DescribeLoadBalancerTargetGroupsResult",
&mut stack,
)?;
skip_tree(&mut stack);
end_element(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn describe_load_balancers(
&self,
input: DescribeLoadBalancersRequest,
) -> RusotoFuture<DescribeLoadBalancersResponse, DescribeLoadBalancersError> {
let mut request = SignedRequest::new("POST", "autoscaling", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeLoadBalancers");
params.put("Version", "2011-01-01");
DescribeLoadBalancersRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response.buffer().from_err().and_then(|response| {
Err(DescribeLoadBalancersError::from_response(response))
}),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeLoadBalancersResponse::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)?;
start_element(&actual_tag_name, &mut stack)?;
result = DescribeLoadBalancersResponseDeserializer::deserialize(
"DescribeLoadBalancersResult",
&mut stack,
)?;
skip_tree(&mut stack);
end_element(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn describe_metric_collection_types(
&self,
) -> RusotoFuture<DescribeMetricCollectionTypesAnswer, DescribeMetricCollectionTypesError> {
let mut request = SignedRequest::new("POST", "autoscaling", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeMetricCollectionTypes");
params.put("Version", "2011-01-01");
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeMetricCollectionTypesError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeMetricCollectionTypesAnswer::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)?;
start_element(&actual_tag_name, &mut stack)?;
result = DescribeMetricCollectionTypesAnswerDeserializer::deserialize(
"DescribeMetricCollectionTypesResult",
&mut stack,
)?;
skip_tree(&mut stack);
end_element(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn describe_notification_configurations(
&self,
input: DescribeNotificationConfigurationsType,
) -> RusotoFuture<
DescribeNotificationConfigurationsAnswer,
DescribeNotificationConfigurationsError,
> {
let mut request = SignedRequest::new("POST", "autoscaling", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeNotificationConfigurations");
params.put("Version", "2011-01-01");
DescribeNotificationConfigurationsTypeSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeNotificationConfigurationsError::from_response(
response,
))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeNotificationConfigurationsAnswer::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)?;
start_element(&actual_tag_name, &mut stack)?;
result = DescribeNotificationConfigurationsAnswerDeserializer::deserialize(
"DescribeNotificationConfigurationsResult",
&mut stack,
)?;
skip_tree(&mut stack);
end_element(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn describe_policies(
&self,
input: DescribePoliciesType,
) -> RusotoFuture<PoliciesType, DescribePoliciesError> {
let mut request = SignedRequest::new("POST", "autoscaling", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribePolicies");
params.put("Version", "2011-01-01");
DescribePoliciesTypeSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DescribePoliciesError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = PoliciesType::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)?;
start_element(&actual_tag_name, &mut stack)?;
result = PoliciesTypeDeserializer::deserialize(
"DescribePoliciesResult",
&mut stack,
)?;
skip_tree(&mut stack);
end_element(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn describe_scaling_activities(
&self,
input: DescribeScalingActivitiesType,
) -> RusotoFuture<ActivitiesType, DescribeScalingActivitiesError> {
let mut request = SignedRequest::new("POST", "autoscaling", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeScalingActivities");
params.put("Version", "2011-01-01");
DescribeScalingActivitiesTypeSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeScalingActivitiesError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = ActivitiesType::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)?;
start_element(&actual_tag_name, &mut stack)?;
result = ActivitiesTypeDeserializer::deserialize(
"DescribeScalingActivitiesResult",
&mut stack,
)?;
skip_tree(&mut stack);
end_element(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn describe_scaling_process_types(
&self,
) -> RusotoFuture<ProcessesType, DescribeScalingProcessTypesError> {
let mut request = SignedRequest::new("POST", "autoscaling", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeScalingProcessTypes");
params.put("Version", "2011-01-01");
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeScalingProcessTypesError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = ProcessesType::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)?;
start_element(&actual_tag_name, &mut stack)?;
result = ProcessesTypeDeserializer::deserialize(
"DescribeScalingProcessTypesResult",
&mut stack,
)?;
skip_tree(&mut stack);
end_element(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn describe_scheduled_actions(
&self,
input: DescribeScheduledActionsType,
) -> RusotoFuture<ScheduledActionsType, DescribeScheduledActionsError> {
let mut request = SignedRequest::new("POST", "autoscaling", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeScheduledActions");
params.put("Version", "2011-01-01");
DescribeScheduledActionsTypeSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeScheduledActionsError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = ScheduledActionsType::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)?;
start_element(&actual_tag_name, &mut stack)?;
result = ScheduledActionsTypeDeserializer::deserialize(
"DescribeScheduledActionsResult",
&mut stack,
)?;
skip_tree(&mut stack);
end_element(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn describe_tags(&self, input: DescribeTagsType) -> RusotoFuture<TagsType, DescribeTagsError> {
let mut request = SignedRequest::new("POST", "autoscaling", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeTags");
params.put("Version", "2011-01-01");
DescribeTagsTypeSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DescribeTagsError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = TagsType::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)?;
start_element(&actual_tag_name, &mut stack)?;
result = TagsTypeDeserializer::deserialize("DescribeTagsResult", &mut stack)?;
skip_tree(&mut stack);
end_element(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn describe_termination_policy_types(
&self,
) -> RusotoFuture<DescribeTerminationPolicyTypesAnswer, DescribeTerminationPolicyTypesError>
{
let mut request = SignedRequest::new("POST", "autoscaling", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeTerminationPolicyTypes");
params.put("Version", "2011-01-01");
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeTerminationPolicyTypesError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeTerminationPolicyTypesAnswer::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)?;
start_element(&actual_tag_name, &mut stack)?;
result = DescribeTerminationPolicyTypesAnswerDeserializer::deserialize(
"DescribeTerminationPolicyTypesResult",
&mut stack,
)?;
skip_tree(&mut stack);
end_element(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn detach_instances(
&self,
input: DetachInstancesQuery,
) -> RusotoFuture<DetachInstancesAnswer, DetachInstancesError> {
let mut request = SignedRequest::new("POST", "autoscaling", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DetachInstances");
params.put("Version", "2011-01-01");
DetachInstancesQuerySerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DetachInstancesError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DetachInstancesAnswer::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)?;
start_element(&actual_tag_name, &mut stack)?;
result = DetachInstancesAnswerDeserializer::deserialize(
"DetachInstancesResult",
&mut stack,
)?;
skip_tree(&mut stack);
end_element(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn detach_load_balancer_target_groups(
&self,
input: DetachLoadBalancerTargetGroupsType,
) -> RusotoFuture<DetachLoadBalancerTargetGroupsResultType, DetachLoadBalancerTargetGroupsError>
{
let mut request = SignedRequest::new("POST", "autoscaling", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DetachLoadBalancerTargetGroups");
params.put("Version", "2011-01-01");
DetachLoadBalancerTargetGroupsTypeSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DetachLoadBalancerTargetGroupsError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DetachLoadBalancerTargetGroupsResultType::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)?;
start_element(&actual_tag_name, &mut stack)?;
result = DetachLoadBalancerTargetGroupsResultTypeDeserializer::deserialize(
"DetachLoadBalancerTargetGroupsResult",
&mut stack,
)?;
skip_tree(&mut stack);
end_element(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn detach_load_balancers(
&self,
input: DetachLoadBalancersType,
) -> RusotoFuture<DetachLoadBalancersResultType, DetachLoadBalancersError> {
let mut request = SignedRequest::new("POST", "autoscaling", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DetachLoadBalancers");
params.put("Version", "2011-01-01");
DetachLoadBalancersTypeSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response.buffer().from_err().and_then(|response| {
Err(DetachLoadBalancersError::from_response(response))
}),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DetachLoadBalancersResultType::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)?;
start_element(&actual_tag_name, &mut stack)?;
result = DetachLoadBalancersResultTypeDeserializer::deserialize(
"DetachLoadBalancersResult",
&mut stack,
)?;
skip_tree(&mut stack);
end_element(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn disable_metrics_collection(
&self,
input: DisableMetricsCollectionQuery,
) -> RusotoFuture<(), DisableMetricsCollectionError> {
let mut request = SignedRequest::new("POST", "autoscaling", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DisableMetricsCollection");
params.put("Version", "2011-01-01");
DisableMetricsCollectionQuerySerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DisableMetricsCollectionError::from_response(response))
}));
}
Box::new(future::ok(::std::mem::drop(response)))
})
}
fn enable_metrics_collection(
&self,
input: EnableMetricsCollectionQuery,
) -> RusotoFuture<(), EnableMetricsCollectionError> {
let mut request = SignedRequest::new("POST", "autoscaling", &self.region, "/");
let mut params = Params::new();
params.put("Action", "EnableMetricsCollection");
params.put("Version", "2011-01-01");
EnableMetricsCollectionQuerySerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(EnableMetricsCollectionError::from_response(response))
}));
}
Box::new(future::ok(::std::mem::drop(response)))
})
}
fn enter_standby(
&self,
input: EnterStandbyQuery,
) -> RusotoFuture<EnterStandbyAnswer, EnterStandbyError> {
let mut request = SignedRequest::new("POST", "autoscaling", &self.region, "/");
let mut params = Params::new();
params.put("Action", "EnterStandby");
params.put("Version", "2011-01-01");
EnterStandbyQuerySerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(EnterStandbyError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = EnterStandbyAnswer::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)?;
start_element(&actual_tag_name, &mut stack)?;
result = EnterStandbyAnswerDeserializer::deserialize(
"EnterStandbyResult",
&mut stack,
)?;
skip_tree(&mut stack);
end_element(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn execute_policy(&self, input: ExecutePolicyType) -> RusotoFuture<(), ExecutePolicyError> {
let mut request = SignedRequest::new("POST", "autoscaling", &self.region, "/");
let mut params = Params::new();
params.put("Action", "ExecutePolicy");
params.put("Version", "2011-01-01");
ExecutePolicyTypeSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(ExecutePolicyError::from_response(response))),
);
}
Box::new(future::ok(::std::mem::drop(response)))
})
}
fn exit_standby(
&self,
input: ExitStandbyQuery,
) -> RusotoFuture<ExitStandbyAnswer, ExitStandbyError> {
let mut request = SignedRequest::new("POST", "autoscaling", &self.region, "/");
let mut params = Params::new();
params.put("Action", "ExitStandby");
params.put("Version", "2011-01-01");
ExitStandbyQuerySerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(ExitStandbyError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = ExitStandbyAnswer::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)?;
start_element(&actual_tag_name, &mut stack)?;
result = ExitStandbyAnswerDeserializer::deserialize(
"ExitStandbyResult",
&mut stack,
)?;
skip_tree(&mut stack);
end_element(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn put_lifecycle_hook(
&self,
input: PutLifecycleHookType,
) -> RusotoFuture<PutLifecycleHookAnswer, PutLifecycleHookError> {
let mut request = SignedRequest::new("POST", "autoscaling", &self.region, "/");
let mut params = Params::new();
params.put("Action", "PutLifecycleHook");
params.put("Version", "2011-01-01");
PutLifecycleHookTypeSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(PutLifecycleHookError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = PutLifecycleHookAnswer::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)?;
start_element(&actual_tag_name, &mut stack)?;
result = PutLifecycleHookAnswerDeserializer::deserialize(
"PutLifecycleHookResult",
&mut stack,
)?;
skip_tree(&mut stack);
end_element(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn put_notification_configuration(
&self,
input: PutNotificationConfigurationType,
) -> RusotoFuture<(), PutNotificationConfigurationError> {
let mut request = SignedRequest::new("POST", "autoscaling", &self.region, "/");
let mut params = Params::new();
params.put("Action", "PutNotificationConfiguration");
params.put("Version", "2011-01-01");
PutNotificationConfigurationTypeSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(PutNotificationConfigurationError::from_response(response))
}));
}
Box::new(future::ok(::std::mem::drop(response)))
})
}
fn put_scaling_policy(
&self,
input: PutScalingPolicyType,
) -> RusotoFuture<PolicyARNType, PutScalingPolicyError> {
let mut request = SignedRequest::new("POST", "autoscaling", &self.region, "/");
let mut params = Params::new();
params.put("Action", "PutScalingPolicy");
params.put("Version", "2011-01-01");
PutScalingPolicyTypeSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(PutScalingPolicyError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = PolicyARNType::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)?;
start_element(&actual_tag_name, &mut stack)?;
result = PolicyARNTypeDeserializer::deserialize(
"PutScalingPolicyResult",
&mut stack,
)?;
skip_tree(&mut stack);
end_element(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn put_scheduled_update_group_action(
&self,
input: PutScheduledUpdateGroupActionType,
) -> RusotoFuture<(), PutScheduledUpdateGroupActionError> {
let mut request = SignedRequest::new("POST", "autoscaling", &self.region, "/");
let mut params = Params::new();
params.put("Action", "PutScheduledUpdateGroupAction");
params.put("Version", "2011-01-01");
PutScheduledUpdateGroupActionTypeSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(PutScheduledUpdateGroupActionError::from_response(response))
}));
}
Box::new(future::ok(::std::mem::drop(response)))
})
}
fn record_lifecycle_action_heartbeat(
&self,
input: RecordLifecycleActionHeartbeatType,
) -> RusotoFuture<RecordLifecycleActionHeartbeatAnswer, RecordLifecycleActionHeartbeatError>
{
let mut request = SignedRequest::new("POST", "autoscaling", &self.region, "/");
let mut params = Params::new();
params.put("Action", "RecordLifecycleActionHeartbeat");
params.put("Version", "2011-01-01");
RecordLifecycleActionHeartbeatTypeSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(RecordLifecycleActionHeartbeatError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = RecordLifecycleActionHeartbeatAnswer::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)?;
start_element(&actual_tag_name, &mut stack)?;
result = RecordLifecycleActionHeartbeatAnswerDeserializer::deserialize(
"RecordLifecycleActionHeartbeatResult",
&mut stack,
)?;
skip_tree(&mut stack);
end_element(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn resume_processes(
&self,
input: ScalingProcessQuery,
) -> RusotoFuture<(), ResumeProcessesError> {
let mut request = SignedRequest::new("POST", "autoscaling", &self.region, "/");
let mut params = Params::new();
params.put("Action", "ResumeProcesses");
params.put("Version", "2011-01-01");
ScalingProcessQuerySerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(ResumeProcessesError::from_response(response))),
);
}
Box::new(future::ok(::std::mem::drop(response)))
})
}
fn set_desired_capacity(
&self,
input: SetDesiredCapacityType,
) -> RusotoFuture<(), SetDesiredCapacityError> {
let mut request = SignedRequest::new("POST", "autoscaling", &self.region, "/");
let mut params = Params::new();
params.put("Action", "SetDesiredCapacity");
params.put("Version", "2011-01-01");
SetDesiredCapacityTypeSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(SetDesiredCapacityError::from_response(response))),
);
}
Box::new(future::ok(::std::mem::drop(response)))
})
}
fn set_instance_health(
&self,
input: SetInstanceHealthQuery,
) -> RusotoFuture<(), SetInstanceHealthError> {
let mut request = SignedRequest::new("POST", "autoscaling", &self.region, "/");
let mut params = Params::new();
params.put("Action", "SetInstanceHealth");
params.put("Version", "2011-01-01");
SetInstanceHealthQuerySerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(SetInstanceHealthError::from_response(response))),
);
}
Box::new(future::ok(::std::mem::drop(response)))
})
}
fn set_instance_protection(
&self,
input: SetInstanceProtectionQuery,
) -> RusotoFuture<SetInstanceProtectionAnswer, SetInstanceProtectionError> {
let mut request = SignedRequest::new("POST", "autoscaling", &self.region, "/");
let mut params = Params::new();
params.put("Action", "SetInstanceProtection");
params.put("Version", "2011-01-01");
SetInstanceProtectionQuerySerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response.buffer().from_err().and_then(|response| {
Err(SetInstanceProtectionError::from_response(response))
}),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = SetInstanceProtectionAnswer::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)?;
start_element(&actual_tag_name, &mut stack)?;
result = SetInstanceProtectionAnswerDeserializer::deserialize(
"SetInstanceProtectionResult",
&mut stack,
)?;
skip_tree(&mut stack);
end_element(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn suspend_processes(
&self,
input: ScalingProcessQuery,
) -> RusotoFuture<(), SuspendProcessesError> {
let mut request = SignedRequest::new("POST", "autoscaling", &self.region, "/");
let mut params = Params::new();
params.put("Action", "SuspendProcesses");
params.put("Version", "2011-01-01");
ScalingProcessQuerySerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(SuspendProcessesError::from_response(response))),
);
}
Box::new(future::ok(::std::mem::drop(response)))
})
}
fn terminate_instance_in_auto_scaling_group(
&self,
input: TerminateInstanceInAutoScalingGroupType,
) -> RusotoFuture<ActivityType, TerminateInstanceInAutoScalingGroupError> {
let mut request = SignedRequest::new("POST", "autoscaling", &self.region, "/");
let mut params = Params::new();
params.put("Action", "TerminateInstanceInAutoScalingGroup");
params.put("Version", "2011-01-01");
TerminateInstanceInAutoScalingGroupTypeSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(TerminateInstanceInAutoScalingGroupError::from_response(
response,
))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = ActivityType::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)?;
start_element(&actual_tag_name, &mut stack)?;
result = ActivityTypeDeserializer::deserialize(
"TerminateInstanceInAutoScalingGroupResult",
&mut stack,
)?;
skip_tree(&mut stack);
end_element(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn update_auto_scaling_group(
&self,
input: UpdateAutoScalingGroupType,
) -> RusotoFuture<(), UpdateAutoScalingGroupError> {
let mut request = SignedRequest::new("POST", "autoscaling", &self.region, "/");
let mut params = Params::new();
params.put("Action", "UpdateAutoScalingGroup");
params.put("Version", "2011-01-01");
UpdateAutoScalingGroupTypeSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(UpdateAutoScalingGroupError::from_response(response))
}));
}
Box::new(future::ok(::std::mem::drop(response)))
})
}
}
#[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_autoscaling_delete_policy() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/error",
"autoscaling-delete-policy.xml",
);
let mock = MockRequestDispatcher::with_status(400).with_body(&mock_response);
let client =
AutoscalingClient::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = DeletePolicyType::default();
let result = client.delete_policy(request).sync();
assert!(!result.is_ok(), "parse error: {:?}", result);
}
#[test]
fn test_parse_valid_autoscaling_describe_adjustment_types() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"autoscaling-describe-adjustment-types.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client =
AutoscalingClient::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let result = client.describe_adjustment_types().sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
fn test_parse_valid_autoscaling_describe_auto_scaling_groups() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"autoscaling-describe-auto-scaling-groups.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client =
AutoscalingClient::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = AutoScalingGroupNamesType::default();
let result = client.describe_auto_scaling_groups(request).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
fn test_parse_valid_autoscaling_describe_auto_scaling_instances() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"autoscaling-describe-auto-scaling-instances.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client =
AutoscalingClient::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = DescribeAutoScalingInstancesType::default();
let result = client.describe_auto_scaling_instances(request).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
fn test_parse_valid_autoscaling_describe_auto_scaling_notification_types() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"autoscaling-describe-auto-scaling-notification-types.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client =
AutoscalingClient::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let result = client.describe_auto_scaling_notification_types().sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
fn test_parse_valid_autoscaling_describe_launch_configurations() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"autoscaling-describe-launch-configurations.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client =
AutoscalingClient::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = LaunchConfigurationNamesType::default();
let result = client.describe_launch_configurations(request).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
fn test_parse_valid_autoscaling_describe_metric_collection_types() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"autoscaling-describe-metric-collection-types.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client =
AutoscalingClient::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let result = client.describe_metric_collection_types().sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
fn test_parse_valid_autoscaling_describe_notification_configurations() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"autoscaling-describe-notification-configurations.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client =
AutoscalingClient::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = DescribeNotificationConfigurationsType::default();
let result = client.describe_notification_configurations(request).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
fn test_parse_valid_autoscaling_describe_policies() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"autoscaling-describe-policies.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client =
AutoscalingClient::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = DescribePoliciesType::default();
let result = client.describe_policies(request).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
fn test_parse_valid_autoscaling_describe_scaling_activities() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"autoscaling-describe-scaling-activities.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client =
AutoscalingClient::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = DescribeScalingActivitiesType::default();
let result = client.describe_scaling_activities(request).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
fn test_parse_valid_autoscaling_describe_scaling_process_types() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"autoscaling-describe-scaling-process-types.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client =
AutoscalingClient::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let result = client.describe_scaling_process_types().sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
fn test_parse_valid_autoscaling_describe_scheduled_actions() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"autoscaling-describe-scheduled-actions.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client =
AutoscalingClient::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = DescribeScheduledActionsType::default();
let result = client.describe_scheduled_actions(request).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
fn test_parse_valid_autoscaling_describe_tags() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"autoscaling-describe-tags.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client =
AutoscalingClient::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = DescribeTagsType::default();
let result = client.describe_tags(request).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
fn test_parse_valid_autoscaling_describe_termination_policy_types() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"autoscaling-describe-termination-policy-types.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client =
AutoscalingClient::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let result = client.describe_termination_policy_types().sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
}