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 ActionsEnabledDeserializer;
impl ActionsEnabledDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<bool, XmlParseError> {
try!(start_element(tag_name, stack));
let obj = bool::from_str(try!(characters(stack)).as_ref()).unwrap();
try!(end_element(tag_name, stack));
Ok(obj)
}
}
struct AlarmArnDeserializer;
impl AlarmArnDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
try!(start_element(tag_name, stack));
let obj = try!(characters(stack));
try!(end_element(tag_name, stack));
Ok(obj)
}
}
struct AlarmDescriptionDeserializer;
impl AlarmDescriptionDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
try!(start_element(tag_name, stack));
let obj = try!(characters(stack));
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct AlarmHistoryItem {
pub alarm_name: Option<String>,
pub history_data: Option<String>,
pub history_item_type: Option<String>,
pub history_summary: Option<String>,
pub timestamp: Option<String>,
}
struct AlarmHistoryItemDeserializer;
impl AlarmHistoryItemDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<AlarmHistoryItem, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = AlarmHistoryItem::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[..] {
"AlarmName" => {
obj.alarm_name =
Some(try!(AlarmNameDeserializer::deserialize("AlarmName", stack)));
}
"HistoryData" => {
obj.history_data = Some(try!(HistoryDataDeserializer::deserialize(
"HistoryData",
stack
)));
}
"HistoryItemType" => {
obj.history_item_type = Some(try!(
HistoryItemTypeDeserializer::deserialize("HistoryItemType", stack)
));
}
"HistorySummary" => {
obj.history_summary = Some(try!(HistorySummaryDeserializer::deserialize(
"HistorySummary",
stack
)));
}
"Timestamp" => {
obj.timestamp =
Some(try!(TimestampDeserializer::deserialize("Timestamp", stack)));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
struct AlarmHistoryItemsDeserializer;
impl AlarmHistoryItemsDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<AlarmHistoryItem>, XmlParseError> {
let mut obj = vec![];
try!(start_element(tag_name, stack));
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "member" {
obj.push(try!(AlarmHistoryItemDeserializer::deserialize(
"member", stack
)));
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
try!(end_element(tag_name, stack));
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
struct AlarmNameDeserializer;
impl AlarmNameDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
try!(start_element(tag_name, stack));
let obj = try!(characters(stack));
try!(end_element(tag_name, stack));
Ok(obj)
}
}
struct AlarmNamesSerializer;
impl AlarmNamesSerializer {
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 ComparisonOperatorDeserializer;
impl ComparisonOperatorDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
try!(start_element(tag_name, stack));
let obj = try!(characters(stack));
try!(end_element(tag_name, stack));
Ok(obj)
}
}
struct DashboardArnDeserializer;
impl DashboardArnDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
try!(start_element(tag_name, stack));
let obj = try!(characters(stack));
try!(end_element(tag_name, stack));
Ok(obj)
}
}
struct DashboardBodyDeserializer;
impl DashboardBodyDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
try!(start_element(tag_name, stack));
let obj = try!(characters(stack));
try!(end_element(tag_name, stack));
Ok(obj)
}
}
struct DashboardEntriesDeserializer;
impl DashboardEntriesDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<DashboardEntry>, XmlParseError> {
let mut obj = vec![];
try!(start_element(tag_name, stack));
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "member" {
obj.push(try!(DashboardEntryDeserializer::deserialize(
"member", stack
)));
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
try!(end_element(tag_name, stack));
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DashboardEntry {
pub dashboard_arn: Option<String>,
pub dashboard_name: Option<String>,
pub last_modified: Option<String>,
pub size: Option<i64>,
}
struct DashboardEntryDeserializer;
impl DashboardEntryDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DashboardEntry, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = DashboardEntry::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[..] {
"DashboardArn" => {
obj.dashboard_arn = Some(try!(DashboardArnDeserializer::deserialize(
"DashboardArn",
stack
)));
}
"DashboardName" => {
obj.dashboard_name = Some(try!(DashboardNameDeserializer::deserialize(
"DashboardName",
stack
)));
}
"LastModified" => {
obj.last_modified = Some(try!(LastModifiedDeserializer::deserialize(
"LastModified",
stack
)));
}
"Size" => {
obj.size = Some(try!(SizeDeserializer::deserialize("Size", stack)));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
struct DashboardNameDeserializer;
impl DashboardNameDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
try!(start_element(tag_name, stack));
let obj = try!(characters(stack));
try!(end_element(tag_name, stack));
Ok(obj)
}
}
struct DashboardNamesSerializer;
impl DashboardNamesSerializer {
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 DashboardValidationMessage {
pub data_path: Option<String>,
pub message: Option<String>,
}
struct DashboardValidationMessageDeserializer;
impl DashboardValidationMessageDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DashboardValidationMessage, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = DashboardValidationMessage::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[..] {
"DataPath" => {
obj.data_path =
Some(try!(DataPathDeserializer::deserialize("DataPath", stack)));
}
"Message" => {
obj.message =
Some(try!(MessageDeserializer::deserialize("Message", stack)));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
struct DashboardValidationMessagesDeserializer;
impl DashboardValidationMessagesDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<DashboardValidationMessage>, XmlParseError> {
let mut obj = vec![];
try!(start_element(tag_name, stack));
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "member" {
obj.push(try!(DashboardValidationMessageDeserializer::deserialize(
"member", stack
)));
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
try!(end_element(tag_name, stack));
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
struct DataPathDeserializer;
impl DataPathDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
try!(start_element(tag_name, stack));
let obj = try!(characters(stack));
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct Datapoint {
pub average: Option<f64>,
pub extended_statistics: Option<::std::collections::HashMap<String, f64>>,
pub maximum: Option<f64>,
pub minimum: Option<f64>,
pub sample_count: Option<f64>,
pub sum: Option<f64>,
pub timestamp: Option<String>,
pub unit: Option<String>,
}
struct DatapointDeserializer;
impl DatapointDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Datapoint, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = Datapoint::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[..] {
"Average" => {
obj.average = Some(try!(DatapointValueDeserializer::deserialize(
"Average", stack
)));
}
"ExtendedStatistics" => {
obj.extended_statistics = Some(try!(
DatapointValueMapDeserializer::deserialize("ExtendedStatistics", stack)
));
}
"Maximum" => {
obj.maximum = Some(try!(DatapointValueDeserializer::deserialize(
"Maximum", stack
)));
}
"Minimum" => {
obj.minimum = Some(try!(DatapointValueDeserializer::deserialize(
"Minimum", stack
)));
}
"SampleCount" => {
obj.sample_count = Some(try!(DatapointValueDeserializer::deserialize(
"SampleCount",
stack
)));
}
"Sum" => {
obj.sum = Some(try!(DatapointValueDeserializer::deserialize("Sum", stack)));
}
"Timestamp" => {
obj.timestamp =
Some(try!(TimestampDeserializer::deserialize("Timestamp", stack)));
}
"Unit" => {
obj.unit = Some(try!(StandardUnitDeserializer::deserialize("Unit", stack)));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
struct DatapointValueDeserializer;
impl DatapointValueDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<f64, XmlParseError> {
try!(start_element(tag_name, stack));
let obj = f64::from_str(try!(characters(stack)).as_ref()).unwrap();
try!(end_element(tag_name, stack));
Ok(obj)
}
}
struct DatapointValueMapDeserializer;
impl DatapointValueMapDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<::std::collections::HashMap<String, f64>, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = ::std::collections::HashMap::new();
while try!(peek_at_name(stack)) == "entry" {
try!(start_element("entry", stack));
let key = try!(ExtendedStatisticDeserializer::deserialize("key", stack));
let value = try!(DatapointValueDeserializer::deserialize("value", stack));
obj.insert(key, value);
try!(end_element("entry", stack));
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
struct DatapointValuesDeserializer;
impl DatapointValuesDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<f64>, XmlParseError> {
let mut obj = vec![];
try!(start_element(tag_name, stack));
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "member" {
obj.push(try!(DatapointValueDeserializer::deserialize(
"member", stack
)));
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
try!(end_element(tag_name, stack));
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
struct DatapointsDeserializer;
impl DatapointsDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<Datapoint>, XmlParseError> {
let mut obj = vec![];
try!(start_element(tag_name, stack));
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "member" {
obj.push(try!(DatapointDeserializer::deserialize("member", stack)));
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
try!(end_element(tag_name, stack));
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
struct DatapointsToAlarmDeserializer;
impl DatapointsToAlarmDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<i64, XmlParseError> {
try!(start_element(tag_name, stack));
let obj = i64::from_str(try!(characters(stack)).as_ref()).unwrap();
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DeleteAlarmsInput {
pub alarm_names: Vec<String>,
}
struct DeleteAlarmsInputSerializer;
impl DeleteAlarmsInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DeleteAlarmsInput) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
AlarmNamesSerializer::serialize(
params,
&format!("{}{}", prefix, "AlarmNames"),
&obj.alarm_names,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DeleteDashboardsInput {
pub dashboard_names: Vec<String>,
}
struct DeleteDashboardsInputSerializer;
impl DeleteDashboardsInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DeleteDashboardsInput) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
DashboardNamesSerializer::serialize(
params,
&format!("{}{}", prefix, "DashboardNames"),
&obj.dashboard_names,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DeleteDashboardsOutput {}
struct DeleteDashboardsOutputDeserializer;
impl DeleteDashboardsOutputDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DeleteDashboardsOutput, XmlParseError> {
try!(start_element(tag_name, stack));
let obj = DeleteDashboardsOutput::default();
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeAlarmHistoryInput {
pub alarm_name: Option<String>,
pub end_date: Option<String>,
pub history_item_type: Option<String>,
pub max_records: Option<i64>,
pub next_token: Option<String>,
pub start_date: Option<String>,
}
struct DescribeAlarmHistoryInputSerializer;
impl DescribeAlarmHistoryInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeAlarmHistoryInput) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.alarm_name {
params.put(&format!("{}{}", prefix, "AlarmName"), &field_value);
}
if let Some(ref field_value) = obj.end_date {
params.put(&format!("{}{}", prefix, "EndDate"), &field_value);
}
if let Some(ref field_value) = obj.history_item_type {
params.put(&format!("{}{}", prefix, "HistoryItemType"), &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.start_date {
params.put(&format!("{}{}", prefix, "StartDate"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeAlarmHistoryOutput {
pub alarm_history_items: Option<Vec<AlarmHistoryItem>>,
pub next_token: Option<String>,
}
struct DescribeAlarmHistoryOutputDeserializer;
impl DescribeAlarmHistoryOutputDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeAlarmHistoryOutput, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = DescribeAlarmHistoryOutput::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[..] {
"AlarmHistoryItems" => {
obj.alarm_history_items = match obj.alarm_history_items {
Some(ref mut existing) => {
existing.extend(try!(AlarmHistoryItemsDeserializer::deserialize(
"AlarmHistoryItems",
stack
)));
Some(existing.to_vec())
}
None => Some(try!(AlarmHistoryItemsDeserializer::deserialize(
"AlarmHistoryItems",
stack
))),
};
}
"NextToken" => {
obj.next_token =
Some(try!(NextTokenDeserializer::deserialize("NextToken", stack)));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeAlarmsForMetricInput {
pub dimensions: Option<Vec<Dimension>>,
pub extended_statistic: Option<String>,
pub metric_name: String,
pub namespace: String,
pub period: Option<i64>,
pub statistic: Option<String>,
pub unit: Option<String>,
}
struct DescribeAlarmsForMetricInputSerializer;
impl DescribeAlarmsForMetricInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeAlarmsForMetricInput) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dimensions {
DimensionsSerializer::serialize(
params,
&format!("{}{}", prefix, "Dimensions"),
field_value,
);
}
if let Some(ref field_value) = obj.extended_statistic {
params.put(&format!("{}{}", prefix, "ExtendedStatistic"), &field_value);
}
params.put(&format!("{}{}", prefix, "MetricName"), &obj.metric_name);
params.put(&format!("{}{}", prefix, "Namespace"), &obj.namespace);
if let Some(ref field_value) = obj.period {
params.put(&format!("{}{}", prefix, "Period"), &field_value.to_string());
}
if let Some(ref field_value) = obj.statistic {
params.put(&format!("{}{}", prefix, "Statistic"), &field_value);
}
if let Some(ref field_value) = obj.unit {
params.put(&format!("{}{}", prefix, "Unit"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeAlarmsForMetricOutput {
pub metric_alarms: Option<Vec<MetricAlarm>>,
}
struct DescribeAlarmsForMetricOutputDeserializer;
impl DescribeAlarmsForMetricOutputDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeAlarmsForMetricOutput, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = DescribeAlarmsForMetricOutput::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[..] {
"MetricAlarms" => {
obj.metric_alarms = match obj.metric_alarms {
Some(ref mut existing) => {
existing.extend(try!(MetricAlarmsDeserializer::deserialize(
"MetricAlarms",
stack
)));
Some(existing.to_vec())
}
None => Some(try!(MetricAlarmsDeserializer::deserialize(
"MetricAlarms",
stack
))),
};
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeAlarmsInput {
pub action_prefix: Option<String>,
pub alarm_name_prefix: Option<String>,
pub alarm_names: Option<Vec<String>>,
pub max_records: Option<i64>,
pub next_token: Option<String>,
pub state_value: Option<String>,
}
struct DescribeAlarmsInputSerializer;
impl DescribeAlarmsInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeAlarmsInput) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.action_prefix {
params.put(&format!("{}{}", prefix, "ActionPrefix"), &field_value);
}
if let Some(ref field_value) = obj.alarm_name_prefix {
params.put(&format!("{}{}", prefix, "AlarmNamePrefix"), &field_value);
}
if let Some(ref field_value) = obj.alarm_names {
AlarmNamesSerializer::serialize(
params,
&format!("{}{}", prefix, "AlarmNames"),
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.state_value {
params.put(&format!("{}{}", prefix, "StateValue"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeAlarmsOutput {
pub metric_alarms: Option<Vec<MetricAlarm>>,
pub next_token: Option<String>,
}
struct DescribeAlarmsOutputDeserializer;
impl DescribeAlarmsOutputDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeAlarmsOutput, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = DescribeAlarmsOutput::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[..] {
"MetricAlarms" => {
obj.metric_alarms = match obj.metric_alarms {
Some(ref mut existing) => {
existing.extend(try!(MetricAlarmsDeserializer::deserialize(
"MetricAlarms",
stack
)));
Some(existing.to_vec())
}
None => Some(try!(MetricAlarmsDeserializer::deserialize(
"MetricAlarms",
stack
))),
};
}
"NextToken" => {
obj.next_token =
Some(try!(NextTokenDeserializer::deserialize("NextToken", stack)));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct Dimension {
pub name: String,
pub value: String,
}
struct DimensionDeserializer;
impl DimensionDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Dimension, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = Dimension::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"Name" => {
obj.name = try!(DimensionNameDeserializer::deserialize("Name", stack));
}
"Value" => {
obj.value = try!(DimensionValueDeserializer::deserialize("Value", stack));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
struct DimensionSerializer;
impl DimensionSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Dimension) {
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);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DimensionFilter {
pub name: String,
pub value: Option<String>,
}
struct DimensionFilterSerializer;
impl DimensionFilterSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DimensionFilter) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(&format!("{}{}", prefix, "Name"), &obj.name);
if let Some(ref field_value) = obj.value {
params.put(&format!("{}{}", prefix, "Value"), &field_value);
}
}
}
struct DimensionFiltersSerializer;
impl DimensionFiltersSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<DimensionFilter>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.member.{}", name, index + 1);
DimensionFilterSerializer::serialize(params, &key, obj);
}
}
}
struct DimensionNameDeserializer;
impl DimensionNameDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
try!(start_element(tag_name, stack));
let obj = try!(characters(stack));
try!(end_element(tag_name, stack));
Ok(obj)
}
}
struct DimensionValueDeserializer;
impl DimensionValueDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
try!(start_element(tag_name, stack));
let obj = try!(characters(stack));
try!(end_element(tag_name, stack));
Ok(obj)
}
}
struct DimensionsDeserializer;
impl DimensionsDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<Dimension>, XmlParseError> {
let mut obj = vec![];
try!(start_element(tag_name, stack));
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "member" {
obj.push(try!(DimensionDeserializer::deserialize("member", stack)));
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
try!(end_element(tag_name, stack));
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
struct DimensionsSerializer;
impl DimensionsSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<Dimension>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.member.{}", name, index + 1);
DimensionSerializer::serialize(params, &key, obj);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DisableAlarmActionsInput {
pub alarm_names: Vec<String>,
}
struct DisableAlarmActionsInputSerializer;
impl DisableAlarmActionsInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DisableAlarmActionsInput) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
AlarmNamesSerializer::serialize(
params,
&format!("{}{}", prefix, "AlarmNames"),
&obj.alarm_names,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct EnableAlarmActionsInput {
pub alarm_names: Vec<String>,
}
struct EnableAlarmActionsInputSerializer;
impl EnableAlarmActionsInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &EnableAlarmActionsInput) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
AlarmNamesSerializer::serialize(
params,
&format!("{}{}", prefix, "AlarmNames"),
&obj.alarm_names,
);
}
}
struct EvaluateLowSampleCountPercentileDeserializer;
impl EvaluateLowSampleCountPercentileDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
try!(start_element(tag_name, stack));
let obj = try!(characters(stack));
try!(end_element(tag_name, stack));
Ok(obj)
}
}
struct EvaluationPeriodsDeserializer;
impl EvaluationPeriodsDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<i64, XmlParseError> {
try!(start_element(tag_name, stack));
let obj = i64::from_str(try!(characters(stack)).as_ref()).unwrap();
try!(end_element(tag_name, stack));
Ok(obj)
}
}
struct ExtendedStatisticDeserializer;
impl ExtendedStatisticDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
try!(start_element(tag_name, stack));
let obj = try!(characters(stack));
try!(end_element(tag_name, stack));
Ok(obj)
}
}
struct ExtendedStatisticsSerializer;
impl ExtendedStatisticsSerializer {
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 GetDashboardInput {
pub dashboard_name: String,
}
struct GetDashboardInputSerializer;
impl GetDashboardInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &GetDashboardInput) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "DashboardName"),
&obj.dashboard_name,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct GetDashboardOutput {
pub dashboard_arn: Option<String>,
pub dashboard_body: Option<String>,
pub dashboard_name: Option<String>,
}
struct GetDashboardOutputDeserializer;
impl GetDashboardOutputDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<GetDashboardOutput, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = GetDashboardOutput::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[..] {
"DashboardArn" => {
obj.dashboard_arn = Some(try!(DashboardArnDeserializer::deserialize(
"DashboardArn",
stack
)));
}
"DashboardBody" => {
obj.dashboard_body = Some(try!(
DashboardBodyDeserializer::deserialize("DashboardBody", stack)
));
}
"DashboardName" => {
obj.dashboard_name = Some(try!(
DashboardNameDeserializer::deserialize("DashboardName", stack)
));
}
_ => skip_tree(stack),
}
}
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct GetMetricDataInput {
pub end_time: String,
pub max_datapoints: Option<i64>,
pub metric_data_queries: Vec<MetricDataQuery>,
pub next_token: Option<String>,
pub scan_by: Option<String>,
pub start_time: String,
}
struct GetMetricDataInputSerializer;
impl GetMetricDataInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &GetMetricDataInput) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(&format!("{}{}", prefix, "EndTime"), &obj.end_time);
if let Some(ref field_value) = obj.max_datapoints {
params.put(
&format!("{}{}", prefix, "MaxDatapoints"),
&field_value.to_string(),
);
}
MetricDataQueriesSerializer::serialize(
params,
&format!("{}{}", prefix, "MetricDataQueries"),
&obj.metric_data_queries,
);
if let Some(ref field_value) = obj.next_token {
params.put(&format!("{}{}", prefix, "NextToken"), &field_value);
}
if let Some(ref field_value) = obj.scan_by {
params.put(&format!("{}{}", prefix, "ScanBy"), &field_value);
}
params.put(&format!("{}{}", prefix, "StartTime"), &obj.start_time);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct GetMetricDataOutput {
pub metric_data_results: Option<Vec<MetricDataResult>>,
pub next_token: Option<String>,
}
struct GetMetricDataOutputDeserializer;
impl GetMetricDataOutputDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<GetMetricDataOutput, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = GetMetricDataOutput::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[..] {
"MetricDataResults" => {
obj.metric_data_results = match obj.metric_data_results {
Some(ref mut existing) => {
existing.extend(try!(MetricDataResultsDeserializer::deserialize(
"MetricDataResults",
stack
)));
Some(existing.to_vec())
}
None => Some(try!(MetricDataResultsDeserializer::deserialize(
"MetricDataResults",
stack
))),
};
}
"NextToken" => {
obj.next_token =
Some(try!(NextTokenDeserializer::deserialize("NextToken", stack)));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct GetMetricStatisticsInput {
pub dimensions: Option<Vec<Dimension>>,
pub end_time: String,
pub extended_statistics: Option<Vec<String>>,
pub metric_name: String,
pub namespace: String,
pub period: i64,
pub start_time: String,
pub statistics: Option<Vec<String>>,
pub unit: Option<String>,
}
struct GetMetricStatisticsInputSerializer;
impl GetMetricStatisticsInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &GetMetricStatisticsInput) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dimensions {
DimensionsSerializer::serialize(
params,
&format!("{}{}", prefix, "Dimensions"),
field_value,
);
}
params.put(&format!("{}{}", prefix, "EndTime"), &obj.end_time);
if let Some(ref field_value) = obj.extended_statistics {
ExtendedStatisticsSerializer::serialize(
params,
&format!("{}{}", prefix, "ExtendedStatistics"),
field_value,
);
}
params.put(&format!("{}{}", prefix, "MetricName"), &obj.metric_name);
params.put(&format!("{}{}", prefix, "Namespace"), &obj.namespace);
params.put(&format!("{}{}", prefix, "Period"), &obj.period.to_string());
params.put(&format!("{}{}", prefix, "StartTime"), &obj.start_time);
if let Some(ref field_value) = obj.statistics {
StatisticsSerializer::serialize(
params,
&format!("{}{}", prefix, "Statistics"),
field_value,
);
}
if let Some(ref field_value) = obj.unit {
params.put(&format!("{}{}", prefix, "Unit"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct GetMetricStatisticsOutput {
pub datapoints: Option<Vec<Datapoint>>,
pub label: Option<String>,
}
struct GetMetricStatisticsOutputDeserializer;
impl GetMetricStatisticsOutputDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<GetMetricStatisticsOutput, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = GetMetricStatisticsOutput::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[..] {
"Datapoints" => {
obj.datapoints = match obj.datapoints {
Some(ref mut existing) => {
existing.extend(try!(DatapointsDeserializer::deserialize(
"Datapoints",
stack
)));
Some(existing.to_vec())
}
None => Some(try!(DatapointsDeserializer::deserialize(
"Datapoints",
stack
))),
};
}
"Label" => {
obj.label =
Some(try!(MetricLabelDeserializer::deserialize("Label", stack)));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
struct HistoryDataDeserializer;
impl HistoryDataDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
try!(start_element(tag_name, stack));
let obj = try!(characters(stack));
try!(end_element(tag_name, stack));
Ok(obj)
}
}
struct HistoryItemTypeDeserializer;
impl HistoryItemTypeDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
try!(start_element(tag_name, stack));
let obj = try!(characters(stack));
try!(end_element(tag_name, stack));
Ok(obj)
}
}
struct HistorySummaryDeserializer;
impl HistorySummaryDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
try!(start_element(tag_name, stack));
let obj = try!(characters(stack));
try!(end_element(tag_name, stack));
Ok(obj)
}
}
struct LastModifiedDeserializer;
impl LastModifiedDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
try!(start_element(tag_name, stack));
let obj = try!(characters(stack));
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ListDashboardsInput {
pub dashboard_name_prefix: Option<String>,
pub next_token: Option<String>,
}
struct ListDashboardsInputSerializer;
impl ListDashboardsInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ListDashboardsInput) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dashboard_name_prefix {
params.put(
&format!("{}{}", prefix, "DashboardNamePrefix"),
&field_value,
);
}
if let Some(ref field_value) = obj.next_token {
params.put(&format!("{}{}", prefix, "NextToken"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ListDashboardsOutput {
pub dashboard_entries: Option<Vec<DashboardEntry>>,
pub next_token: Option<String>,
}
struct ListDashboardsOutputDeserializer;
impl ListDashboardsOutputDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ListDashboardsOutput, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = ListDashboardsOutput::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[..] {
"DashboardEntries" => {
obj.dashboard_entries = match obj.dashboard_entries {
Some(ref mut existing) => {
existing.extend(try!(DashboardEntriesDeserializer::deserialize(
"DashboardEntries",
stack
)));
Some(existing.to_vec())
}
None => Some(try!(DashboardEntriesDeserializer::deserialize(
"DashboardEntries",
stack
))),
};
}
"NextToken" => {
obj.next_token =
Some(try!(NextTokenDeserializer::deserialize("NextToken", stack)));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ListMetricsInput {
pub dimensions: Option<Vec<DimensionFilter>>,
pub metric_name: Option<String>,
pub namespace: Option<String>,
pub next_token: Option<String>,
}
struct ListMetricsInputSerializer;
impl ListMetricsInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ListMetricsInput) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dimensions {
DimensionFiltersSerializer::serialize(
params,
&format!("{}{}", prefix, "Dimensions"),
field_value,
);
}
if let Some(ref field_value) = obj.metric_name {
params.put(&format!("{}{}", prefix, "MetricName"), &field_value);
}
if let Some(ref field_value) = obj.namespace {
params.put(&format!("{}{}", prefix, "Namespace"), &field_value);
}
if let Some(ref field_value) = obj.next_token {
params.put(&format!("{}{}", prefix, "NextToken"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ListMetricsOutput {
pub metrics: Option<Vec<Metric>>,
pub next_token: Option<String>,
}
struct ListMetricsOutputDeserializer;
impl ListMetricsOutputDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ListMetricsOutput, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = ListMetricsOutput::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[..] {
"Metrics" => {
obj.metrics = match obj.metrics {
Some(ref mut existing) => {
existing.extend(try!(MetricsDeserializer::deserialize(
"Metrics", stack
)));
Some(existing.to_vec())
}
None => Some(try!(MetricsDeserializer::deserialize("Metrics", stack))),
};
}
"NextToken" => {
obj.next_token =
Some(try!(NextTokenDeserializer::deserialize("NextToken", stack)));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
struct MessageDeserializer;
impl MessageDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
try!(start_element(tag_name, stack));
let obj = try!(characters(stack));
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct MessageData {
pub code: Option<String>,
pub value: Option<String>,
}
struct MessageDataDeserializer;
impl MessageDataDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<MessageData, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = MessageData::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[..] {
"Code" => {
obj.code = Some(try!(MessageDataCodeDeserializer::deserialize(
"Code", stack
)));
}
"Value" => {
obj.value = Some(try!(MessageDataValueDeserializer::deserialize(
"Value", stack
)));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
struct MessageDataCodeDeserializer;
impl MessageDataCodeDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
try!(start_element(tag_name, stack));
let obj = try!(characters(stack));
try!(end_element(tag_name, stack));
Ok(obj)
}
}
struct MessageDataValueDeserializer;
impl MessageDataValueDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
try!(start_element(tag_name, stack));
let obj = try!(characters(stack));
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct Metric {
pub dimensions: Option<Vec<Dimension>>,
pub metric_name: Option<String>,
pub namespace: Option<String>,
}
struct MetricDeserializer;
impl MetricDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Metric, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = Metric::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(try!(DimensionsDeserializer::deserialize(
"Dimensions",
stack
)));
Some(existing.to_vec())
}
None => Some(try!(DimensionsDeserializer::deserialize(
"Dimensions",
stack
))),
};
}
"MetricName" => {
obj.metric_name = Some(try!(MetricNameDeserializer::deserialize(
"MetricName",
stack
)));
}
"Namespace" => {
obj.namespace =
Some(try!(NamespaceDeserializer::deserialize("Namespace", stack)));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
struct MetricSerializer;
impl MetricSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Metric) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dimensions {
DimensionsSerializer::serialize(
params,
&format!("{}{}", prefix, "Dimensions"),
field_value,
);
}
if let Some(ref field_value) = obj.metric_name {
params.put(&format!("{}{}", prefix, "MetricName"), &field_value);
}
if let Some(ref field_value) = obj.namespace {
params.put(&format!("{}{}", prefix, "Namespace"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct MetricAlarm {
pub actions_enabled: Option<bool>,
pub alarm_actions: Option<Vec<String>>,
pub alarm_arn: Option<String>,
pub alarm_configuration_updated_timestamp: Option<String>,
pub alarm_description: Option<String>,
pub alarm_name: Option<String>,
pub comparison_operator: Option<String>,
pub datapoints_to_alarm: Option<i64>,
pub dimensions: Option<Vec<Dimension>>,
pub evaluate_low_sample_count_percentile: Option<String>,
pub evaluation_periods: Option<i64>,
pub extended_statistic: Option<String>,
pub insufficient_data_actions: Option<Vec<String>>,
pub metric_name: Option<String>,
pub namespace: Option<String>,
pub ok_actions: Option<Vec<String>>,
pub period: Option<i64>,
pub state_reason: Option<String>,
pub state_reason_data: Option<String>,
pub state_updated_timestamp: Option<String>,
pub state_value: Option<String>,
pub statistic: Option<String>,
pub threshold: Option<f64>,
pub treat_missing_data: Option<String>,
pub unit: Option<String>,
}
struct MetricAlarmDeserializer;
impl MetricAlarmDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<MetricAlarm, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = MetricAlarm::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[..] {
"ActionsEnabled" => {
obj.actions_enabled = Some(try!(ActionsEnabledDeserializer::deserialize(
"ActionsEnabled",
stack
)));
}
"AlarmActions" => {
obj.alarm_actions = match obj.alarm_actions {
Some(ref mut existing) => {
existing.extend(try!(ResourceListDeserializer::deserialize(
"AlarmActions",
stack
)));
Some(existing.to_vec())
}
None => Some(try!(ResourceListDeserializer::deserialize(
"AlarmActions",
stack
))),
};
}
"AlarmArn" => {
obj.alarm_arn =
Some(try!(AlarmArnDeserializer::deserialize("AlarmArn", stack)));
}
"AlarmConfigurationUpdatedTimestamp" => {
obj.alarm_configuration_updated_timestamp =
Some(try!(TimestampDeserializer::deserialize(
"AlarmConfigurationUpdatedTimestamp",
stack
)));
}
"AlarmDescription" => {
obj.alarm_description = Some(try!(
AlarmDescriptionDeserializer::deserialize("AlarmDescription", stack)
));
}
"AlarmName" => {
obj.alarm_name =
Some(try!(AlarmNameDeserializer::deserialize("AlarmName", stack)));
}
"ComparisonOperator" => {
obj.comparison_operator =
Some(try!(ComparisonOperatorDeserializer::deserialize(
"ComparisonOperator",
stack
)));
}
"DatapointsToAlarm" => {
obj.datapoints_to_alarm = Some(try!(
DatapointsToAlarmDeserializer::deserialize("DatapointsToAlarm", stack)
));
}
"Dimensions" => {
obj.dimensions = match obj.dimensions {
Some(ref mut existing) => {
existing.extend(try!(DimensionsDeserializer::deserialize(
"Dimensions",
stack
)));
Some(existing.to_vec())
}
None => Some(try!(DimensionsDeserializer::deserialize(
"Dimensions",
stack
))),
};
}
"EvaluateLowSampleCountPercentile" => {
obj.evaluate_low_sample_count_percentile = Some(try!(
EvaluateLowSampleCountPercentileDeserializer::deserialize(
"EvaluateLowSampleCountPercentile",
stack
)
));
}
"EvaluationPeriods" => {
obj.evaluation_periods = Some(try!(
EvaluationPeriodsDeserializer::deserialize("EvaluationPeriods", stack)
));
}
"ExtendedStatistic" => {
obj.extended_statistic = Some(try!(
ExtendedStatisticDeserializer::deserialize("ExtendedStatistic", stack)
));
}
"InsufficientDataActions" => {
obj.insufficient_data_actions = match obj.insufficient_data_actions {
Some(ref mut existing) => {
existing.extend(try!(ResourceListDeserializer::deserialize(
"InsufficientDataActions",
stack
)));
Some(existing.to_vec())
}
None => Some(try!(ResourceListDeserializer::deserialize(
"InsufficientDataActions",
stack
))),
};
}
"MetricName" => {
obj.metric_name = Some(try!(MetricNameDeserializer::deserialize(
"MetricName",
stack
)));
}
"Namespace" => {
obj.namespace =
Some(try!(NamespaceDeserializer::deserialize("Namespace", stack)));
}
"OKActions" => {
obj.ok_actions = match obj.ok_actions {
Some(ref mut existing) => {
existing.extend(try!(ResourceListDeserializer::deserialize(
"OKActions",
stack
)));
Some(existing.to_vec())
}
None => Some(try!(ResourceListDeserializer::deserialize(
"OKActions",
stack
))),
};
}
"Period" => {
obj.period = Some(try!(PeriodDeserializer::deserialize("Period", stack)));
}
"StateReason" => {
obj.state_reason = Some(try!(StateReasonDeserializer::deserialize(
"StateReason",
stack
)));
}
"StateReasonData" => {
obj.state_reason_data = Some(try!(
StateReasonDataDeserializer::deserialize("StateReasonData", stack)
));
}
"StateUpdatedTimestamp" => {
obj.state_updated_timestamp = Some(try!(
TimestampDeserializer::deserialize("StateUpdatedTimestamp", stack)
));
}
"StateValue" => {
obj.state_value = Some(try!(StateValueDeserializer::deserialize(
"StateValue",
stack
)));
}
"Statistic" => {
obj.statistic =
Some(try!(StatisticDeserializer::deserialize("Statistic", stack)));
}
"Threshold" => {
obj.threshold =
Some(try!(ThresholdDeserializer::deserialize("Threshold", stack)));
}
"TreatMissingData" => {
obj.treat_missing_data = Some(try!(
TreatMissingDataDeserializer::deserialize("TreatMissingData", stack)
));
}
"Unit" => {
obj.unit = Some(try!(StandardUnitDeserializer::deserialize("Unit", stack)));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
struct MetricAlarmsDeserializer;
impl MetricAlarmsDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<MetricAlarm>, XmlParseError> {
let mut obj = vec![];
try!(start_element(tag_name, stack));
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "member" {
obj.push(try!(MetricAlarmDeserializer::deserialize("member", stack)));
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
try!(end_element(tag_name, stack));
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
struct MetricDataSerializer;
impl MetricDataSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<MetricDatum>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.member.{}", name, index + 1);
MetricDatumSerializer::serialize(params, &key, obj);
}
}
}
struct MetricDataQueriesSerializer;
impl MetricDataQueriesSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<MetricDataQuery>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.member.{}", name, index + 1);
MetricDataQuerySerializer::serialize(params, &key, obj);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct MetricDataQuery {
pub expression: Option<String>,
pub id: String,
pub label: Option<String>,
pub metric_stat: Option<MetricStat>,
pub return_data: Option<bool>,
}
struct MetricDataQuerySerializer;
impl MetricDataQuerySerializer {
fn serialize(params: &mut Params, name: &str, obj: &MetricDataQuery) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.expression {
params.put(&format!("{}{}", prefix, "Expression"), &field_value);
}
params.put(&format!("{}{}", prefix, "Id"), &obj.id);
if let Some(ref field_value) = obj.label {
params.put(&format!("{}{}", prefix, "Label"), &field_value);
}
if let Some(ref field_value) = obj.metric_stat {
MetricStatSerializer::serialize(
params,
&format!("{}{}", prefix, "MetricStat"),
field_value,
);
}
if let Some(ref field_value) = obj.return_data {
params.put(
&format!("{}{}", prefix, "ReturnData"),
&field_value.to_string(),
);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct MetricDataResult {
pub id: Option<String>,
pub label: Option<String>,
pub messages: Option<Vec<MessageData>>,
pub status_code: Option<String>,
pub timestamps: Option<Vec<String>>,
pub values: Option<Vec<f64>>,
}
struct MetricDataResultDeserializer;
impl MetricDataResultDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<MetricDataResult, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = MetricDataResult::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"Id" => {
obj.id = Some(try!(MetricIdDeserializer::deserialize("Id", stack)));
}
"Label" => {
obj.label =
Some(try!(MetricLabelDeserializer::deserialize("Label", stack)));
}
"Messages" => {
obj.messages = match obj.messages {
Some(ref mut existing) => {
existing.extend(try!(
MetricDataResultMessagesDeserializer::deserialize(
"Messages", stack
)
));
Some(existing.to_vec())
}
None => Some(try!(MetricDataResultMessagesDeserializer::deserialize(
"Messages", stack
))),
};
}
"StatusCode" => {
obj.status_code = Some(try!(StatusCodeDeserializer::deserialize(
"StatusCode",
stack
)));
}
"Timestamps" => {
obj.timestamps = match obj.timestamps {
Some(ref mut existing) => {
existing.extend(try!(TimestampsDeserializer::deserialize(
"Timestamps",
stack
)));
Some(existing.to_vec())
}
None => Some(try!(TimestampsDeserializer::deserialize(
"Timestamps",
stack
))),
};
}
"Values" => {
obj.values = match obj.values {
Some(ref mut existing) => {
existing.extend(try!(DatapointValuesDeserializer::deserialize(
"Values", stack
)));
Some(existing.to_vec())
}
None => Some(try!(DatapointValuesDeserializer::deserialize(
"Values", stack
))),
};
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
struct MetricDataResultMessagesDeserializer;
impl MetricDataResultMessagesDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<MessageData>, XmlParseError> {
let mut obj = vec![];
try!(start_element(tag_name, stack));
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "member" {
obj.push(try!(MessageDataDeserializer::deserialize("member", stack)));
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
try!(end_element(tag_name, stack));
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
struct MetricDataResultsDeserializer;
impl MetricDataResultsDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<MetricDataResult>, XmlParseError> {
let mut obj = vec![];
try!(start_element(tag_name, stack));
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "member" {
obj.push(try!(MetricDataResultDeserializer::deserialize(
"member", stack
)));
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
try!(end_element(tag_name, stack));
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct MetricDatum {
pub dimensions: Option<Vec<Dimension>>,
pub metric_name: String,
pub statistic_values: Option<StatisticSet>,
pub storage_resolution: Option<i64>,
pub timestamp: Option<String>,
pub unit: Option<String>,
pub value: Option<f64>,
}
struct MetricDatumSerializer;
impl MetricDatumSerializer {
fn serialize(params: &mut Params, name: &str, obj: &MetricDatum) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dimensions {
DimensionsSerializer::serialize(
params,
&format!("{}{}", prefix, "Dimensions"),
field_value,
);
}
params.put(&format!("{}{}", prefix, "MetricName"), &obj.metric_name);
if let Some(ref field_value) = obj.statistic_values {
StatisticSetSerializer::serialize(
params,
&format!("{}{}", prefix, "StatisticValues"),
field_value,
);
}
if let Some(ref field_value) = obj.storage_resolution {
params.put(
&format!("{}{}", prefix, "StorageResolution"),
&field_value.to_string(),
);
}
if let Some(ref field_value) = obj.timestamp {
params.put(&format!("{}{}", prefix, "Timestamp"), &field_value);
}
if let Some(ref field_value) = obj.unit {
params.put(&format!("{}{}", prefix, "Unit"), &field_value);
}
if let Some(ref field_value) = obj.value {
params.put(&format!("{}{}", prefix, "Value"), &field_value.to_string());
}
}
}
struct MetricIdDeserializer;
impl MetricIdDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
try!(start_element(tag_name, stack));
let obj = try!(characters(stack));
try!(end_element(tag_name, stack));
Ok(obj)
}
}
struct MetricLabelDeserializer;
impl MetricLabelDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
try!(start_element(tag_name, stack));
let obj = try!(characters(stack));
try!(end_element(tag_name, stack));
Ok(obj)
}
}
struct MetricNameDeserializer;
impl MetricNameDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
try!(start_element(tag_name, stack));
let obj = try!(characters(stack));
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct MetricStat {
pub metric: Metric,
pub period: i64,
pub stat: String,
pub unit: Option<String>,
}
struct MetricStatSerializer;
impl MetricStatSerializer {
fn serialize(params: &mut Params, name: &str, obj: &MetricStat) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
MetricSerializer::serialize(params, &format!("{}{}", prefix, "Metric"), &obj.metric);
params.put(&format!("{}{}", prefix, "Period"), &obj.period.to_string());
params.put(&format!("{}{}", prefix, "Stat"), &obj.stat);
if let Some(ref field_value) = obj.unit {
params.put(&format!("{}{}", prefix, "Unit"), &field_value);
}
}
}
struct MetricsDeserializer;
impl MetricsDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<Metric>, XmlParseError> {
let mut obj = vec![];
try!(start_element(tag_name, stack));
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "member" {
obj.push(try!(MetricDeserializer::deserialize("member", stack)));
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
try!(end_element(tag_name, stack));
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
struct NamespaceDeserializer;
impl NamespaceDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
try!(start_element(tag_name, stack));
let obj = try!(characters(stack));
try!(end_element(tag_name, stack));
Ok(obj)
}
}
struct NextTokenDeserializer;
impl NextTokenDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
try!(start_element(tag_name, stack));
let obj = try!(characters(stack));
try!(end_element(tag_name, stack));
Ok(obj)
}
}
struct PeriodDeserializer;
impl PeriodDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<i64, XmlParseError> {
try!(start_element(tag_name, stack));
let obj = i64::from_str(try!(characters(stack)).as_ref()).unwrap();
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct PutDashboardInput {
pub dashboard_body: String,
pub dashboard_name: String,
}
struct PutDashboardInputSerializer;
impl PutDashboardInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &PutDashboardInput) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "DashboardBody"),
&obj.dashboard_body,
);
params.put(
&format!("{}{}", prefix, "DashboardName"),
&obj.dashboard_name,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct PutDashboardOutput {
pub dashboard_validation_messages: Option<Vec<DashboardValidationMessage>>,
}
struct PutDashboardOutputDeserializer;
impl PutDashboardOutputDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<PutDashboardOutput, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = PutDashboardOutput::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[..] {
"DashboardValidationMessages" => {
obj.dashboard_validation_messages = match obj.dashboard_validation_messages
{
Some(ref mut existing) => {
existing.extend(try!(
DashboardValidationMessagesDeserializer::deserialize(
"DashboardValidationMessages",
stack
)
));
Some(existing.to_vec())
}
None => {
Some(try!(DashboardValidationMessagesDeserializer::deserialize(
"DashboardValidationMessages",
stack
)))
}
};
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct PutMetricAlarmInput {
pub actions_enabled: Option<bool>,
pub alarm_actions: Option<Vec<String>>,
pub alarm_description: Option<String>,
pub alarm_name: String,
pub comparison_operator: String,
pub datapoints_to_alarm: Option<i64>,
pub dimensions: Option<Vec<Dimension>>,
pub evaluate_low_sample_count_percentile: Option<String>,
pub evaluation_periods: i64,
pub extended_statistic: Option<String>,
pub insufficient_data_actions: Option<Vec<String>>,
pub metric_name: String,
pub namespace: String,
pub ok_actions: Option<Vec<String>>,
pub period: i64,
pub statistic: Option<String>,
pub threshold: f64,
pub treat_missing_data: Option<String>,
pub unit: Option<String>,
}
struct PutMetricAlarmInputSerializer;
impl PutMetricAlarmInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &PutMetricAlarmInput) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.actions_enabled {
params.put(
&format!("{}{}", prefix, "ActionsEnabled"),
&field_value.to_string(),
);
}
if let Some(ref field_value) = obj.alarm_actions {
ResourceListSerializer::serialize(
params,
&format!("{}{}", prefix, "AlarmActions"),
field_value,
);
}
if let Some(ref field_value) = obj.alarm_description {
params.put(&format!("{}{}", prefix, "AlarmDescription"), &field_value);
}
params.put(&format!("{}{}", prefix, "AlarmName"), &obj.alarm_name);
params.put(
&format!("{}{}", prefix, "ComparisonOperator"),
&obj.comparison_operator,
);
if let Some(ref field_value) = obj.datapoints_to_alarm {
params.put(
&format!("{}{}", prefix, "DatapointsToAlarm"),
&field_value.to_string(),
);
}
if let Some(ref field_value) = obj.dimensions {
DimensionsSerializer::serialize(
params,
&format!("{}{}", prefix, "Dimensions"),
field_value,
);
}
if let Some(ref field_value) = obj.evaluate_low_sample_count_percentile {
params.put(
&format!("{}{}", prefix, "EvaluateLowSampleCountPercentile"),
&field_value,
);
}
params.put(
&format!("{}{}", prefix, "EvaluationPeriods"),
&obj.evaluation_periods.to_string(),
);
if let Some(ref field_value) = obj.extended_statistic {
params.put(&format!("{}{}", prefix, "ExtendedStatistic"), &field_value);
}
if let Some(ref field_value) = obj.insufficient_data_actions {
ResourceListSerializer::serialize(
params,
&format!("{}{}", prefix, "InsufficientDataActions"),
field_value,
);
}
params.put(&format!("{}{}", prefix, "MetricName"), &obj.metric_name);
params.put(&format!("{}{}", prefix, "Namespace"), &obj.namespace);
if let Some(ref field_value) = obj.ok_actions {
ResourceListSerializer::serialize(
params,
&format!("{}{}", prefix, "OKActions"),
field_value,
);
}
params.put(&format!("{}{}", prefix, "Period"), &obj.period.to_string());
if let Some(ref field_value) = obj.statistic {
params.put(&format!("{}{}", prefix, "Statistic"), &field_value);
}
params.put(
&format!("{}{}", prefix, "Threshold"),
&obj.threshold.to_string(),
);
if let Some(ref field_value) = obj.treat_missing_data {
params.put(&format!("{}{}", prefix, "TreatMissingData"), &field_value);
}
if let Some(ref field_value) = obj.unit {
params.put(&format!("{}{}", prefix, "Unit"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct PutMetricDataInput {
pub metric_data: Vec<MetricDatum>,
pub namespace: String,
}
struct PutMetricDataInputSerializer;
impl PutMetricDataInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &PutMetricDataInput) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
MetricDataSerializer::serialize(
params,
&format!("{}{}", prefix, "MetricData"),
&obj.metric_data,
);
params.put(&format!("{}{}", prefix, "Namespace"), &obj.namespace);
}
}
struct ResourceListDeserializer;
impl ResourceListDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<String>, XmlParseError> {
let mut obj = vec![];
try!(start_element(tag_name, stack));
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "member" {
obj.push(try!(ResourceNameDeserializer::deserialize("member", stack)));
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
try!(end_element(tag_name, stack));
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
struct ResourceListSerializer;
impl ResourceListSerializer {
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 ResourceNameDeserializer;
impl ResourceNameDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
try!(start_element(tag_name, stack));
let obj = try!(characters(stack));
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct SetAlarmStateInput {
pub alarm_name: String,
pub state_reason: String,
pub state_reason_data: Option<String>,
pub state_value: String,
}
struct SetAlarmStateInputSerializer;
impl SetAlarmStateInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &SetAlarmStateInput) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(&format!("{}{}", prefix, "AlarmName"), &obj.alarm_name);
params.put(&format!("{}{}", prefix, "StateReason"), &obj.state_reason);
if let Some(ref field_value) = obj.state_reason_data {
params.put(&format!("{}{}", prefix, "StateReasonData"), &field_value);
}
params.put(&format!("{}{}", prefix, "StateValue"), &obj.state_value);
}
}
struct SizeDeserializer;
impl SizeDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<i64, XmlParseError> {
try!(start_element(tag_name, stack));
let obj = i64::from_str(try!(characters(stack)).as_ref()).unwrap();
try!(end_element(tag_name, stack));
Ok(obj)
}
}
struct StandardUnitDeserializer;
impl StandardUnitDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
try!(start_element(tag_name, stack));
let obj = try!(characters(stack));
try!(end_element(tag_name, stack));
Ok(obj)
}
}
struct StateReasonDeserializer;
impl StateReasonDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
try!(start_element(tag_name, stack));
let obj = try!(characters(stack));
try!(end_element(tag_name, stack));
Ok(obj)
}
}
struct StateReasonDataDeserializer;
impl StateReasonDataDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
try!(start_element(tag_name, stack));
let obj = try!(characters(stack));
try!(end_element(tag_name, stack));
Ok(obj)
}
}
struct StateValueDeserializer;
impl StateValueDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
try!(start_element(tag_name, stack));
let obj = try!(characters(stack));
try!(end_element(tag_name, stack));
Ok(obj)
}
}
struct StatisticDeserializer;
impl StatisticDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
try!(start_element(tag_name, stack));
let obj = try!(characters(stack));
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct StatisticSet {
pub maximum: f64,
pub minimum: f64,
pub sample_count: f64,
pub sum: f64,
}
struct StatisticSetSerializer;
impl StatisticSetSerializer {
fn serialize(params: &mut Params, name: &str, obj: &StatisticSet) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "Maximum"),
&obj.maximum.to_string(),
);
params.put(
&format!("{}{}", prefix, "Minimum"),
&obj.minimum.to_string(),
);
params.put(
&format!("{}{}", prefix, "SampleCount"),
&obj.sample_count.to_string(),
);
params.put(&format!("{}{}", prefix, "Sum"), &obj.sum.to_string());
}
}
struct StatisticsSerializer;
impl StatisticsSerializer {
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 StatusCodeDeserializer;
impl StatusCodeDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
try!(start_element(tag_name, stack));
let obj = try!(characters(stack));
try!(end_element(tag_name, stack));
Ok(obj)
}
}
struct ThresholdDeserializer;
impl ThresholdDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<f64, XmlParseError> {
try!(start_element(tag_name, stack));
let obj = f64::from_str(try!(characters(stack)).as_ref()).unwrap();
try!(end_element(tag_name, stack));
Ok(obj)
}
}
struct TimestampDeserializer;
impl TimestampDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
try!(start_element(tag_name, stack));
let obj = try!(characters(stack));
try!(end_element(tag_name, stack));
Ok(obj)
}
}
struct TimestampsDeserializer;
impl TimestampsDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<String>, XmlParseError> {
let mut obj = vec![];
try!(start_element(tag_name, stack));
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "member" {
obj.push(try!(TimestampDeserializer::deserialize("member", stack)));
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
try!(end_element(tag_name, stack));
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
struct TreatMissingDataDeserializer;
impl TreatMissingDataDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
try!(start_element(tag_name, stack));
let obj = try!(characters(stack));
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteAlarmsError {
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DeleteAlarmsError {
pub fn from_response(res: BufferedHttpResponse) -> DeleteAlarmsError {
{
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[..] {
"ResourceNotFound" => {
return DeleteAlarmsError::ResourceNotFound(String::from(
parsed_error.message,
))
}
_ => {}
}
}
}
DeleteAlarmsError::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 DeleteAlarmsError {
fn from(err: XmlParseError) -> DeleteAlarmsError {
let XmlParseError(message) = err;
DeleteAlarmsError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DeleteAlarmsError {
fn from(err: CredentialsError) -> DeleteAlarmsError {
DeleteAlarmsError::Credentials(err)
}
}
impl From<HttpDispatchError> for DeleteAlarmsError {
fn from(err: HttpDispatchError) -> DeleteAlarmsError {
DeleteAlarmsError::HttpDispatch(err)
}
}
impl From<io::Error> for DeleteAlarmsError {
fn from(err: io::Error) -> DeleteAlarmsError {
DeleteAlarmsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DeleteAlarmsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteAlarmsError {
fn description(&self) -> &str {
match *self {
DeleteAlarmsError::ResourceNotFound(ref cause) => cause,
DeleteAlarmsError::Validation(ref cause) => cause,
DeleteAlarmsError::Credentials(ref err) => err.description(),
DeleteAlarmsError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
DeleteAlarmsError::ParseError(ref cause) => cause,
DeleteAlarmsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteDashboardsError {
DashboardNotFoundError(String),
InternalServiceFault(String),
InvalidParameterValue(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DeleteDashboardsError {
pub fn from_response(res: BufferedHttpResponse) -> DeleteDashboardsError {
{
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[..] {
"ResourceNotFound" => {
return DeleteDashboardsError::DashboardNotFoundError(String::from(
parsed_error.message,
))
}
"InternalServiceError" => {
return DeleteDashboardsError::InternalServiceFault(String::from(
parsed_error.message,
))
}
"InvalidParameterValue" => {
return DeleteDashboardsError::InvalidParameterValue(String::from(
parsed_error.message,
))
}
_ => {}
}
}
}
DeleteDashboardsError::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 DeleteDashboardsError {
fn from(err: XmlParseError) -> DeleteDashboardsError {
let XmlParseError(message) = err;
DeleteDashboardsError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DeleteDashboardsError {
fn from(err: CredentialsError) -> DeleteDashboardsError {
DeleteDashboardsError::Credentials(err)
}
}
impl From<HttpDispatchError> for DeleteDashboardsError {
fn from(err: HttpDispatchError) -> DeleteDashboardsError {
DeleteDashboardsError::HttpDispatch(err)
}
}
impl From<io::Error> for DeleteDashboardsError {
fn from(err: io::Error) -> DeleteDashboardsError {
DeleteDashboardsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DeleteDashboardsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteDashboardsError {
fn description(&self) -> &str {
match *self {
DeleteDashboardsError::DashboardNotFoundError(ref cause) => cause,
DeleteDashboardsError::InternalServiceFault(ref cause) => cause,
DeleteDashboardsError::InvalidParameterValue(ref cause) => cause,
DeleteDashboardsError::Validation(ref cause) => cause,
DeleteDashboardsError::Credentials(ref err) => err.description(),
DeleteDashboardsError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
DeleteDashboardsError::ParseError(ref cause) => cause,
DeleteDashboardsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeAlarmHistoryError {
InvalidNextToken(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeAlarmHistoryError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeAlarmHistoryError {
{
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 DescribeAlarmHistoryError::InvalidNextToken(String::from(
parsed_error.message,
))
}
_ => {}
}
}
}
DescribeAlarmHistoryError::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 DescribeAlarmHistoryError {
fn from(err: XmlParseError) -> DescribeAlarmHistoryError {
let XmlParseError(message) = err;
DescribeAlarmHistoryError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DescribeAlarmHistoryError {
fn from(err: CredentialsError) -> DescribeAlarmHistoryError {
DescribeAlarmHistoryError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeAlarmHistoryError {
fn from(err: HttpDispatchError) -> DescribeAlarmHistoryError {
DescribeAlarmHistoryError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeAlarmHistoryError {
fn from(err: io::Error) -> DescribeAlarmHistoryError {
DescribeAlarmHistoryError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeAlarmHistoryError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeAlarmHistoryError {
fn description(&self) -> &str {
match *self {
DescribeAlarmHistoryError::InvalidNextToken(ref cause) => cause,
DescribeAlarmHistoryError::Validation(ref cause) => cause,
DescribeAlarmHistoryError::Credentials(ref err) => err.description(),
DescribeAlarmHistoryError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DescribeAlarmHistoryError::ParseError(ref cause) => cause,
DescribeAlarmHistoryError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeAlarmsError {
InvalidNextToken(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeAlarmsError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeAlarmsError {
{
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 DescribeAlarmsError::InvalidNextToken(String::from(
parsed_error.message,
))
}
_ => {}
}
}
}
DescribeAlarmsError::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 DescribeAlarmsError {
fn from(err: XmlParseError) -> DescribeAlarmsError {
let XmlParseError(message) = err;
DescribeAlarmsError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DescribeAlarmsError {
fn from(err: CredentialsError) -> DescribeAlarmsError {
DescribeAlarmsError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeAlarmsError {
fn from(err: HttpDispatchError) -> DescribeAlarmsError {
DescribeAlarmsError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeAlarmsError {
fn from(err: io::Error) -> DescribeAlarmsError {
DescribeAlarmsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeAlarmsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeAlarmsError {
fn description(&self) -> &str {
match *self {
DescribeAlarmsError::InvalidNextToken(ref cause) => cause,
DescribeAlarmsError::Validation(ref cause) => cause,
DescribeAlarmsError::Credentials(ref err) => err.description(),
DescribeAlarmsError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
DescribeAlarmsError::ParseError(ref cause) => cause,
DescribeAlarmsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeAlarmsForMetricError {
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeAlarmsForMetricError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeAlarmsForMetricError {
{
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[..] {
_ => {}
}
}
}
DescribeAlarmsForMetricError::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 DescribeAlarmsForMetricError {
fn from(err: XmlParseError) -> DescribeAlarmsForMetricError {
let XmlParseError(message) = err;
DescribeAlarmsForMetricError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DescribeAlarmsForMetricError {
fn from(err: CredentialsError) -> DescribeAlarmsForMetricError {
DescribeAlarmsForMetricError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeAlarmsForMetricError {
fn from(err: HttpDispatchError) -> DescribeAlarmsForMetricError {
DescribeAlarmsForMetricError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeAlarmsForMetricError {
fn from(err: io::Error) -> DescribeAlarmsForMetricError {
DescribeAlarmsForMetricError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeAlarmsForMetricError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeAlarmsForMetricError {
fn description(&self) -> &str {
match *self {
DescribeAlarmsForMetricError::Validation(ref cause) => cause,
DescribeAlarmsForMetricError::Credentials(ref err) => err.description(),
DescribeAlarmsForMetricError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DescribeAlarmsForMetricError::ParseError(ref cause) => cause,
DescribeAlarmsForMetricError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DisableAlarmActionsError {
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DisableAlarmActionsError {
pub fn from_response(res: BufferedHttpResponse) -> DisableAlarmActionsError {
{
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[..] {
_ => {}
}
}
}
DisableAlarmActionsError::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 DisableAlarmActionsError {
fn from(err: XmlParseError) -> DisableAlarmActionsError {
let XmlParseError(message) = err;
DisableAlarmActionsError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DisableAlarmActionsError {
fn from(err: CredentialsError) -> DisableAlarmActionsError {
DisableAlarmActionsError::Credentials(err)
}
}
impl From<HttpDispatchError> for DisableAlarmActionsError {
fn from(err: HttpDispatchError) -> DisableAlarmActionsError {
DisableAlarmActionsError::HttpDispatch(err)
}
}
impl From<io::Error> for DisableAlarmActionsError {
fn from(err: io::Error) -> DisableAlarmActionsError {
DisableAlarmActionsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DisableAlarmActionsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DisableAlarmActionsError {
fn description(&self) -> &str {
match *self {
DisableAlarmActionsError::Validation(ref cause) => cause,
DisableAlarmActionsError::Credentials(ref err) => err.description(),
DisableAlarmActionsError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DisableAlarmActionsError::ParseError(ref cause) => cause,
DisableAlarmActionsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum EnableAlarmActionsError {
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl EnableAlarmActionsError {
pub fn from_response(res: BufferedHttpResponse) -> EnableAlarmActionsError {
{
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[..] {
_ => {}
}
}
}
EnableAlarmActionsError::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 EnableAlarmActionsError {
fn from(err: XmlParseError) -> EnableAlarmActionsError {
let XmlParseError(message) = err;
EnableAlarmActionsError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for EnableAlarmActionsError {
fn from(err: CredentialsError) -> EnableAlarmActionsError {
EnableAlarmActionsError::Credentials(err)
}
}
impl From<HttpDispatchError> for EnableAlarmActionsError {
fn from(err: HttpDispatchError) -> EnableAlarmActionsError {
EnableAlarmActionsError::HttpDispatch(err)
}
}
impl From<io::Error> for EnableAlarmActionsError {
fn from(err: io::Error) -> EnableAlarmActionsError {
EnableAlarmActionsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for EnableAlarmActionsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for EnableAlarmActionsError {
fn description(&self) -> &str {
match *self {
EnableAlarmActionsError::Validation(ref cause) => cause,
EnableAlarmActionsError::Credentials(ref err) => err.description(),
EnableAlarmActionsError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
EnableAlarmActionsError::ParseError(ref cause) => cause,
EnableAlarmActionsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum GetDashboardError {
DashboardNotFoundError(String),
InternalServiceFault(String),
InvalidParameterValue(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl GetDashboardError {
pub fn from_response(res: BufferedHttpResponse) -> GetDashboardError {
{
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[..] {
"ResourceNotFound" => {
return GetDashboardError::DashboardNotFoundError(String::from(
parsed_error.message,
))
}
"InternalServiceError" => {
return GetDashboardError::InternalServiceFault(String::from(
parsed_error.message,
))
}
"InvalidParameterValue" => {
return GetDashboardError::InvalidParameterValue(String::from(
parsed_error.message,
))
}
_ => {}
}
}
}
GetDashboardError::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 GetDashboardError {
fn from(err: XmlParseError) -> GetDashboardError {
let XmlParseError(message) = err;
GetDashboardError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for GetDashboardError {
fn from(err: CredentialsError) -> GetDashboardError {
GetDashboardError::Credentials(err)
}
}
impl From<HttpDispatchError> for GetDashboardError {
fn from(err: HttpDispatchError) -> GetDashboardError {
GetDashboardError::HttpDispatch(err)
}
}
impl From<io::Error> for GetDashboardError {
fn from(err: io::Error) -> GetDashboardError {
GetDashboardError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for GetDashboardError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetDashboardError {
fn description(&self) -> &str {
match *self {
GetDashboardError::DashboardNotFoundError(ref cause) => cause,
GetDashboardError::InternalServiceFault(ref cause) => cause,
GetDashboardError::InvalidParameterValue(ref cause) => cause,
GetDashboardError::Validation(ref cause) => cause,
GetDashboardError::Credentials(ref err) => err.description(),
GetDashboardError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
GetDashboardError::ParseError(ref cause) => cause,
GetDashboardError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum GetMetricDataError {
InvalidNextToken(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl GetMetricDataError {
pub fn from_response(res: BufferedHttpResponse) -> GetMetricDataError {
{
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 GetMetricDataError::InvalidNextToken(String::from(
parsed_error.message,
))
}
_ => {}
}
}
}
GetMetricDataError::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 GetMetricDataError {
fn from(err: XmlParseError) -> GetMetricDataError {
let XmlParseError(message) = err;
GetMetricDataError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for GetMetricDataError {
fn from(err: CredentialsError) -> GetMetricDataError {
GetMetricDataError::Credentials(err)
}
}
impl From<HttpDispatchError> for GetMetricDataError {
fn from(err: HttpDispatchError) -> GetMetricDataError {
GetMetricDataError::HttpDispatch(err)
}
}
impl From<io::Error> for GetMetricDataError {
fn from(err: io::Error) -> GetMetricDataError {
GetMetricDataError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for GetMetricDataError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetMetricDataError {
fn description(&self) -> &str {
match *self {
GetMetricDataError::InvalidNextToken(ref cause) => cause,
GetMetricDataError::Validation(ref cause) => cause,
GetMetricDataError::Credentials(ref err) => err.description(),
GetMetricDataError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
GetMetricDataError::ParseError(ref cause) => cause,
GetMetricDataError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum GetMetricStatisticsError {
InternalServiceFault(String),
InvalidParameterCombination(String),
InvalidParameterValue(String),
MissingRequiredParameter(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl GetMetricStatisticsError {
pub fn from_response(res: BufferedHttpResponse) -> GetMetricStatisticsError {
{
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[..] {
"InternalServiceError" => {
return GetMetricStatisticsError::InternalServiceFault(String::from(
parsed_error.message,
))
}
"InvalidParameterCombination" => {
return GetMetricStatisticsError::InvalidParameterCombination(String::from(
parsed_error.message,
))
}
"InvalidParameterValue" => {
return GetMetricStatisticsError::InvalidParameterValue(String::from(
parsed_error.message,
))
}
"MissingParameter" => {
return GetMetricStatisticsError::MissingRequiredParameter(String::from(
parsed_error.message,
))
}
_ => {}
}
}
}
GetMetricStatisticsError::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 GetMetricStatisticsError {
fn from(err: XmlParseError) -> GetMetricStatisticsError {
let XmlParseError(message) = err;
GetMetricStatisticsError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for GetMetricStatisticsError {
fn from(err: CredentialsError) -> GetMetricStatisticsError {
GetMetricStatisticsError::Credentials(err)
}
}
impl From<HttpDispatchError> for GetMetricStatisticsError {
fn from(err: HttpDispatchError) -> GetMetricStatisticsError {
GetMetricStatisticsError::HttpDispatch(err)
}
}
impl From<io::Error> for GetMetricStatisticsError {
fn from(err: io::Error) -> GetMetricStatisticsError {
GetMetricStatisticsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for GetMetricStatisticsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetMetricStatisticsError {
fn description(&self) -> &str {
match *self {
GetMetricStatisticsError::InternalServiceFault(ref cause) => cause,
GetMetricStatisticsError::InvalidParameterCombination(ref cause) => cause,
GetMetricStatisticsError::InvalidParameterValue(ref cause) => cause,
GetMetricStatisticsError::MissingRequiredParameter(ref cause) => cause,
GetMetricStatisticsError::Validation(ref cause) => cause,
GetMetricStatisticsError::Credentials(ref err) => err.description(),
GetMetricStatisticsError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
GetMetricStatisticsError::ParseError(ref cause) => cause,
GetMetricStatisticsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ListDashboardsError {
InternalServiceFault(String),
InvalidParameterValue(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ListDashboardsError {
pub fn from_response(res: BufferedHttpResponse) -> ListDashboardsError {
{
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[..] {
"InternalServiceError" => {
return ListDashboardsError::InternalServiceFault(String::from(
parsed_error.message,
))
}
"InvalidParameterValue" => {
return ListDashboardsError::InvalidParameterValue(String::from(
parsed_error.message,
))
}
_ => {}
}
}
}
ListDashboardsError::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 ListDashboardsError {
fn from(err: XmlParseError) -> ListDashboardsError {
let XmlParseError(message) = err;
ListDashboardsError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for ListDashboardsError {
fn from(err: CredentialsError) -> ListDashboardsError {
ListDashboardsError::Credentials(err)
}
}
impl From<HttpDispatchError> for ListDashboardsError {
fn from(err: HttpDispatchError) -> ListDashboardsError {
ListDashboardsError::HttpDispatch(err)
}
}
impl From<io::Error> for ListDashboardsError {
fn from(err: io::Error) -> ListDashboardsError {
ListDashboardsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ListDashboardsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ListDashboardsError {
fn description(&self) -> &str {
match *self {
ListDashboardsError::InternalServiceFault(ref cause) => cause,
ListDashboardsError::InvalidParameterValue(ref cause) => cause,
ListDashboardsError::Validation(ref cause) => cause,
ListDashboardsError::Credentials(ref err) => err.description(),
ListDashboardsError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
ListDashboardsError::ParseError(ref cause) => cause,
ListDashboardsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ListMetricsError {
InternalServiceFault(String),
InvalidParameterValue(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ListMetricsError {
pub fn from_response(res: BufferedHttpResponse) -> ListMetricsError {
{
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[..] {
"InternalServiceError" => {
return ListMetricsError::InternalServiceFault(String::from(
parsed_error.message,
))
}
"InvalidParameterValue" => {
return ListMetricsError::InvalidParameterValue(String::from(
parsed_error.message,
))
}
_ => {}
}
}
}
ListMetricsError::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 ListMetricsError {
fn from(err: XmlParseError) -> ListMetricsError {
let XmlParseError(message) = err;
ListMetricsError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for ListMetricsError {
fn from(err: CredentialsError) -> ListMetricsError {
ListMetricsError::Credentials(err)
}
}
impl From<HttpDispatchError> for ListMetricsError {
fn from(err: HttpDispatchError) -> ListMetricsError {
ListMetricsError::HttpDispatch(err)
}
}
impl From<io::Error> for ListMetricsError {
fn from(err: io::Error) -> ListMetricsError {
ListMetricsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ListMetricsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ListMetricsError {
fn description(&self) -> &str {
match *self {
ListMetricsError::InternalServiceFault(ref cause) => cause,
ListMetricsError::InvalidParameterValue(ref cause) => cause,
ListMetricsError::Validation(ref cause) => cause,
ListMetricsError::Credentials(ref err) => err.description(),
ListMetricsError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
ListMetricsError::ParseError(ref cause) => cause,
ListMetricsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum PutDashboardError {
DashboardInvalidInputError(String),
InternalServiceFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl PutDashboardError {
pub fn from_response(res: BufferedHttpResponse) -> PutDashboardError {
{
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[..] {
"InvalidParameterInput" => {
return PutDashboardError::DashboardInvalidInputError(String::from(
parsed_error.message,
))
}
"InternalServiceError" => {
return PutDashboardError::InternalServiceFault(String::from(
parsed_error.message,
))
}
_ => {}
}
}
}
PutDashboardError::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 PutDashboardError {
fn from(err: XmlParseError) -> PutDashboardError {
let XmlParseError(message) = err;
PutDashboardError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for PutDashboardError {
fn from(err: CredentialsError) -> PutDashboardError {
PutDashboardError::Credentials(err)
}
}
impl From<HttpDispatchError> for PutDashboardError {
fn from(err: HttpDispatchError) -> PutDashboardError {
PutDashboardError::HttpDispatch(err)
}
}
impl From<io::Error> for PutDashboardError {
fn from(err: io::Error) -> PutDashboardError {
PutDashboardError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for PutDashboardError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for PutDashboardError {
fn description(&self) -> &str {
match *self {
PutDashboardError::DashboardInvalidInputError(ref cause) => cause,
PutDashboardError::InternalServiceFault(ref cause) => cause,
PutDashboardError::Validation(ref cause) => cause,
PutDashboardError::Credentials(ref err) => err.description(),
PutDashboardError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
PutDashboardError::ParseError(ref cause) => cause,
PutDashboardError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum PutMetricAlarmError {
LimitExceededFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl PutMetricAlarmError {
pub fn from_response(res: BufferedHttpResponse) -> PutMetricAlarmError {
{
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 PutMetricAlarmError::LimitExceededFault(String::from(
parsed_error.message,
))
}
_ => {}
}
}
}
PutMetricAlarmError::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 PutMetricAlarmError {
fn from(err: XmlParseError) -> PutMetricAlarmError {
let XmlParseError(message) = err;
PutMetricAlarmError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for PutMetricAlarmError {
fn from(err: CredentialsError) -> PutMetricAlarmError {
PutMetricAlarmError::Credentials(err)
}
}
impl From<HttpDispatchError> for PutMetricAlarmError {
fn from(err: HttpDispatchError) -> PutMetricAlarmError {
PutMetricAlarmError::HttpDispatch(err)
}
}
impl From<io::Error> for PutMetricAlarmError {
fn from(err: io::Error) -> PutMetricAlarmError {
PutMetricAlarmError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for PutMetricAlarmError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for PutMetricAlarmError {
fn description(&self) -> &str {
match *self {
PutMetricAlarmError::LimitExceededFault(ref cause) => cause,
PutMetricAlarmError::Validation(ref cause) => cause,
PutMetricAlarmError::Credentials(ref err) => err.description(),
PutMetricAlarmError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
PutMetricAlarmError::ParseError(ref cause) => cause,
PutMetricAlarmError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum PutMetricDataError {
InternalServiceFault(String),
InvalidParameterCombination(String),
InvalidParameterValue(String),
MissingRequiredParameter(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl PutMetricDataError {
pub fn from_response(res: BufferedHttpResponse) -> PutMetricDataError {
{
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[..] {
"InternalServiceError" => {
return PutMetricDataError::InternalServiceFault(String::from(
parsed_error.message,
))
}
"InvalidParameterCombination" => {
return PutMetricDataError::InvalidParameterCombination(String::from(
parsed_error.message,
))
}
"InvalidParameterValue" => {
return PutMetricDataError::InvalidParameterValue(String::from(
parsed_error.message,
))
}
"MissingParameter" => {
return PutMetricDataError::MissingRequiredParameter(String::from(
parsed_error.message,
))
}
_ => {}
}
}
}
PutMetricDataError::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 PutMetricDataError {
fn from(err: XmlParseError) -> PutMetricDataError {
let XmlParseError(message) = err;
PutMetricDataError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for PutMetricDataError {
fn from(err: CredentialsError) -> PutMetricDataError {
PutMetricDataError::Credentials(err)
}
}
impl From<HttpDispatchError> for PutMetricDataError {
fn from(err: HttpDispatchError) -> PutMetricDataError {
PutMetricDataError::HttpDispatch(err)
}
}
impl From<io::Error> for PutMetricDataError {
fn from(err: io::Error) -> PutMetricDataError {
PutMetricDataError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for PutMetricDataError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for PutMetricDataError {
fn description(&self) -> &str {
match *self {
PutMetricDataError::InternalServiceFault(ref cause) => cause,
PutMetricDataError::InvalidParameterCombination(ref cause) => cause,
PutMetricDataError::InvalidParameterValue(ref cause) => cause,
PutMetricDataError::MissingRequiredParameter(ref cause) => cause,
PutMetricDataError::Validation(ref cause) => cause,
PutMetricDataError::Credentials(ref err) => err.description(),
PutMetricDataError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
PutMetricDataError::ParseError(ref cause) => cause,
PutMetricDataError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum SetAlarmStateError {
InvalidFormatFault(String),
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl SetAlarmStateError {
pub fn from_response(res: BufferedHttpResponse) -> SetAlarmStateError {
{
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[..] {
"InvalidFormat" => {
return SetAlarmStateError::InvalidFormatFault(String::from(
parsed_error.message,
))
}
"ResourceNotFound" => {
return SetAlarmStateError::ResourceNotFound(String::from(
parsed_error.message,
))
}
_ => {}
}
}
}
SetAlarmStateError::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 SetAlarmStateError {
fn from(err: XmlParseError) -> SetAlarmStateError {
let XmlParseError(message) = err;
SetAlarmStateError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for SetAlarmStateError {
fn from(err: CredentialsError) -> SetAlarmStateError {
SetAlarmStateError::Credentials(err)
}
}
impl From<HttpDispatchError> for SetAlarmStateError {
fn from(err: HttpDispatchError) -> SetAlarmStateError {
SetAlarmStateError::HttpDispatch(err)
}
}
impl From<io::Error> for SetAlarmStateError {
fn from(err: io::Error) -> SetAlarmStateError {
SetAlarmStateError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for SetAlarmStateError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for SetAlarmStateError {
fn description(&self) -> &str {
match *self {
SetAlarmStateError::InvalidFormatFault(ref cause) => cause,
SetAlarmStateError::ResourceNotFound(ref cause) => cause,
SetAlarmStateError::Validation(ref cause) => cause,
SetAlarmStateError::Credentials(ref err) => err.description(),
SetAlarmStateError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
SetAlarmStateError::ParseError(ref cause) => cause,
SetAlarmStateError::Unknown(_) => "unknown error",
}
}
}
pub trait CloudWatch {
fn delete_alarms(&self, input: DeleteAlarmsInput) -> RusotoFuture<(), DeleteAlarmsError>;
fn delete_dashboards(
&self,
input: DeleteDashboardsInput,
) -> RusotoFuture<DeleteDashboardsOutput, DeleteDashboardsError>;
fn describe_alarm_history(
&self,
input: DescribeAlarmHistoryInput,
) -> RusotoFuture<DescribeAlarmHistoryOutput, DescribeAlarmHistoryError>;
fn describe_alarms(
&self,
input: DescribeAlarmsInput,
) -> RusotoFuture<DescribeAlarmsOutput, DescribeAlarmsError>;
fn describe_alarms_for_metric(
&self,
input: DescribeAlarmsForMetricInput,
) -> RusotoFuture<DescribeAlarmsForMetricOutput, DescribeAlarmsForMetricError>;
fn disable_alarm_actions(
&self,
input: DisableAlarmActionsInput,
) -> RusotoFuture<(), DisableAlarmActionsError>;
fn enable_alarm_actions(
&self,
input: EnableAlarmActionsInput,
) -> RusotoFuture<(), EnableAlarmActionsError>;
fn get_dashboard(
&self,
input: GetDashboardInput,
) -> RusotoFuture<GetDashboardOutput, GetDashboardError>;
fn get_metric_data(
&self,
input: GetMetricDataInput,
) -> RusotoFuture<GetMetricDataOutput, GetMetricDataError>;
fn get_metric_statistics(
&self,
input: GetMetricStatisticsInput,
) -> RusotoFuture<GetMetricStatisticsOutput, GetMetricStatisticsError>;
fn list_dashboards(
&self,
input: ListDashboardsInput,
) -> RusotoFuture<ListDashboardsOutput, ListDashboardsError>;
fn list_metrics(
&self,
input: ListMetricsInput,
) -> RusotoFuture<ListMetricsOutput, ListMetricsError>;
fn put_dashboard(
&self,
input: PutDashboardInput,
) -> RusotoFuture<PutDashboardOutput, PutDashboardError>;
fn put_metric_alarm(&self, input: PutMetricAlarmInput)
-> RusotoFuture<(), PutMetricAlarmError>;
fn put_metric_data(&self, input: PutMetricDataInput) -> RusotoFuture<(), PutMetricDataError>;
fn set_alarm_state(&self, input: SetAlarmStateInput) -> RusotoFuture<(), SetAlarmStateError>;
}
pub struct CloudWatchClient {
client: Client,
region: region::Region,
}
impl CloudWatchClient {
pub fn new(region: region::Region) -> CloudWatchClient {
CloudWatchClient {
client: Client::shared(),
region: region,
}
}
pub fn new_with<P, D>(
request_dispatcher: D,
credentials_provider: P,
region: region::Region,
) -> CloudWatchClient
where
P: ProvideAwsCredentials + Send + Sync + 'static,
P::Future: Send,
D: DispatchSignedRequest + Send + Sync + 'static,
D::Future: Send,
{
CloudWatchClient {
client: Client::new_with(credentials_provider, request_dispatcher),
region: region,
}
}
}
impl CloudWatch for CloudWatchClient {
fn delete_alarms(&self, input: DeleteAlarmsInput) -> RusotoFuture<(), DeleteAlarmsError> {
let mut request = SignedRequest::new("POST", "monitoring", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DeleteAlarms");
params.put("Version", "2010-08-01");
DeleteAlarmsInputSerializer::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(DeleteAlarmsError::from_response(response))),
);
}
Box::new(future::ok(::std::mem::drop(response)))
})
}
fn delete_dashboards(
&self,
input: DeleteDashboardsInput,
) -> RusotoFuture<DeleteDashboardsOutput, DeleteDashboardsError> {
let mut request = SignedRequest::new("POST", "monitoring", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DeleteDashboards");
params.put("Version", "2010-08-01");
DeleteDashboardsInputSerializer::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(DeleteDashboardsError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DeleteDashboardsOutput::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = try!(peek_at_name(&mut stack));
try!(start_element(&actual_tag_name, &mut stack));
result = try!(DeleteDashboardsOutputDeserializer::deserialize(
"DeleteDashboardsResult",
&mut stack
));
skip_tree(&mut stack);
try!(end_element(&actual_tag_name, &mut stack));
}
Ok(result)
}))
})
}
fn describe_alarm_history(
&self,
input: DescribeAlarmHistoryInput,
) -> RusotoFuture<DescribeAlarmHistoryOutput, DescribeAlarmHistoryError> {
let mut request = SignedRequest::new("POST", "monitoring", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeAlarmHistory");
params.put("Version", "2010-08-01");
DescribeAlarmHistoryInputSerializer::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(DescribeAlarmHistoryError::from_response(response))
}),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeAlarmHistoryOutput::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = try!(peek_at_name(&mut stack));
try!(start_element(&actual_tag_name, &mut stack));
result = try!(DescribeAlarmHistoryOutputDeserializer::deserialize(
"DescribeAlarmHistoryResult",
&mut stack
));
skip_tree(&mut stack);
try!(end_element(&actual_tag_name, &mut stack));
}
Ok(result)
}))
})
}
fn describe_alarms(
&self,
input: DescribeAlarmsInput,
) -> RusotoFuture<DescribeAlarmsOutput, DescribeAlarmsError> {
let mut request = SignedRequest::new("POST", "monitoring", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeAlarms");
params.put("Version", "2010-08-01");
DescribeAlarmsInputSerializer::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(DescribeAlarmsError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeAlarmsOutput::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = try!(peek_at_name(&mut stack));
try!(start_element(&actual_tag_name, &mut stack));
result = try!(DescribeAlarmsOutputDeserializer::deserialize(
"DescribeAlarmsResult",
&mut stack
));
skip_tree(&mut stack);
try!(end_element(&actual_tag_name, &mut stack));
}
Ok(result)
}))
})
}
fn describe_alarms_for_metric(
&self,
input: DescribeAlarmsForMetricInput,
) -> RusotoFuture<DescribeAlarmsForMetricOutput, DescribeAlarmsForMetricError> {
let mut request = SignedRequest::new("POST", "monitoring", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeAlarmsForMetric");
params.put("Version", "2010-08-01");
DescribeAlarmsForMetricInputSerializer::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(DescribeAlarmsForMetricError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeAlarmsForMetricOutput::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = try!(peek_at_name(&mut stack));
try!(start_element(&actual_tag_name, &mut stack));
result = try!(DescribeAlarmsForMetricOutputDeserializer::deserialize(
"DescribeAlarmsForMetricResult",
&mut stack
));
skip_tree(&mut stack);
try!(end_element(&actual_tag_name, &mut stack));
}
Ok(result)
}))
})
}
fn disable_alarm_actions(
&self,
input: DisableAlarmActionsInput,
) -> RusotoFuture<(), DisableAlarmActionsError> {
let mut request = SignedRequest::new("POST", "monitoring", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DisableAlarmActions");
params.put("Version", "2010-08-01");
DisableAlarmActionsInputSerializer::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(DisableAlarmActionsError::from_response(response))
}),
);
}
Box::new(future::ok(::std::mem::drop(response)))
})
}
fn enable_alarm_actions(
&self,
input: EnableAlarmActionsInput,
) -> RusotoFuture<(), EnableAlarmActionsError> {
let mut request = SignedRequest::new("POST", "monitoring", &self.region, "/");
let mut params = Params::new();
params.put("Action", "EnableAlarmActions");
params.put("Version", "2010-08-01");
EnableAlarmActionsInputSerializer::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(EnableAlarmActionsError::from_response(response))),
);
}
Box::new(future::ok(::std::mem::drop(response)))
})
}
fn get_dashboard(
&self,
input: GetDashboardInput,
) -> RusotoFuture<GetDashboardOutput, GetDashboardError> {
let mut request = SignedRequest::new("POST", "monitoring", &self.region, "/");
let mut params = Params::new();
params.put("Action", "GetDashboard");
params.put("Version", "2010-08-01");
GetDashboardInputSerializer::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(GetDashboardError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = GetDashboardOutput::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = try!(peek_at_name(&mut stack));
try!(start_element(&actual_tag_name, &mut stack));
result = try!(GetDashboardOutputDeserializer::deserialize(
"GetDashboardResult",
&mut stack
));
skip_tree(&mut stack);
try!(end_element(&actual_tag_name, &mut stack));
}
Ok(result)
}))
})
}
fn get_metric_data(
&self,
input: GetMetricDataInput,
) -> RusotoFuture<GetMetricDataOutput, GetMetricDataError> {
let mut request = SignedRequest::new("POST", "monitoring", &self.region, "/");
let mut params = Params::new();
params.put("Action", "GetMetricData");
params.put("Version", "2010-08-01");
GetMetricDataInputSerializer::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(GetMetricDataError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = GetMetricDataOutput::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = try!(peek_at_name(&mut stack));
try!(start_element(&actual_tag_name, &mut stack));
result = try!(GetMetricDataOutputDeserializer::deserialize(
"GetMetricDataResult",
&mut stack
));
skip_tree(&mut stack);
try!(end_element(&actual_tag_name, &mut stack));
}
Ok(result)
}))
})
}
fn get_metric_statistics(
&self,
input: GetMetricStatisticsInput,
) -> RusotoFuture<GetMetricStatisticsOutput, GetMetricStatisticsError> {
let mut request = SignedRequest::new("POST", "monitoring", &self.region, "/");
let mut params = Params::new();
params.put("Action", "GetMetricStatistics");
params.put("Version", "2010-08-01");
GetMetricStatisticsInputSerializer::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(GetMetricStatisticsError::from_response(response))
}),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = GetMetricStatisticsOutput::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = try!(peek_at_name(&mut stack));
try!(start_element(&actual_tag_name, &mut stack));
result = try!(GetMetricStatisticsOutputDeserializer::deserialize(
"GetMetricStatisticsResult",
&mut stack
));
skip_tree(&mut stack);
try!(end_element(&actual_tag_name, &mut stack));
}
Ok(result)
}))
})
}
fn list_dashboards(
&self,
input: ListDashboardsInput,
) -> RusotoFuture<ListDashboardsOutput, ListDashboardsError> {
let mut request = SignedRequest::new("POST", "monitoring", &self.region, "/");
let mut params = Params::new();
params.put("Action", "ListDashboards");
params.put("Version", "2010-08-01");
ListDashboardsInputSerializer::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(ListDashboardsError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = ListDashboardsOutput::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = try!(peek_at_name(&mut stack));
try!(start_element(&actual_tag_name, &mut stack));
result = try!(ListDashboardsOutputDeserializer::deserialize(
"ListDashboardsResult",
&mut stack
));
skip_tree(&mut stack);
try!(end_element(&actual_tag_name, &mut stack));
}
Ok(result)
}))
})
}
fn list_metrics(
&self,
input: ListMetricsInput,
) -> RusotoFuture<ListMetricsOutput, ListMetricsError> {
let mut request = SignedRequest::new("POST", "monitoring", &self.region, "/");
let mut params = Params::new();
params.put("Action", "ListMetrics");
params.put("Version", "2010-08-01");
ListMetricsInputSerializer::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(ListMetricsError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = ListMetricsOutput::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = try!(peek_at_name(&mut stack));
try!(start_element(&actual_tag_name, &mut stack));
result = try!(ListMetricsOutputDeserializer::deserialize(
"ListMetricsResult",
&mut stack
));
skip_tree(&mut stack);
try!(end_element(&actual_tag_name, &mut stack));
}
Ok(result)
}))
})
}
fn put_dashboard(
&self,
input: PutDashboardInput,
) -> RusotoFuture<PutDashboardOutput, PutDashboardError> {
let mut request = SignedRequest::new("POST", "monitoring", &self.region, "/");
let mut params = Params::new();
params.put("Action", "PutDashboard");
params.put("Version", "2010-08-01");
PutDashboardInputSerializer::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(PutDashboardError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = PutDashboardOutput::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = try!(peek_at_name(&mut stack));
try!(start_element(&actual_tag_name, &mut stack));
result = try!(PutDashboardOutputDeserializer::deserialize(
"PutDashboardResult",
&mut stack
));
skip_tree(&mut stack);
try!(end_element(&actual_tag_name, &mut stack));
}
Ok(result)
}))
})
}
fn put_metric_alarm(
&self,
input: PutMetricAlarmInput,
) -> RusotoFuture<(), PutMetricAlarmError> {
let mut request = SignedRequest::new("POST", "monitoring", &self.region, "/");
let mut params = Params::new();
params.put("Action", "PutMetricAlarm");
params.put("Version", "2010-08-01");
PutMetricAlarmInputSerializer::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(PutMetricAlarmError::from_response(response))),
);
}
Box::new(future::ok(::std::mem::drop(response)))
})
}
fn put_metric_data(&self, input: PutMetricDataInput) -> RusotoFuture<(), PutMetricDataError> {
let mut request = SignedRequest::new("POST", "monitoring", &self.region, "/");
let mut params = Params::new();
params.put("Action", "PutMetricData");
params.put("Version", "2010-08-01");
PutMetricDataInputSerializer::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(PutMetricDataError::from_response(response))),
);
}
Box::new(future::ok(::std::mem::drop(response)))
})
}
fn set_alarm_state(&self, input: SetAlarmStateInput) -> RusotoFuture<(), SetAlarmStateError> {
let mut request = SignedRequest::new("POST", "monitoring", &self.region, "/");
let mut params = Params::new();
params.put("Action", "SetAlarmState");
params.put("Version", "2010-08-01");
SetAlarmStateInputSerializer::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(SetAlarmStateError::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_cloudwatch_describe_alarm_history() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/error",
"cloudwatch-describe-alarm-history.xml",
);
let mock = MockRequestDispatcher::with_status(400).with_body(&mock_response);
let client =
CloudWatchClient::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = DescribeAlarmHistoryInput::default();
let result = client.describe_alarm_history(request).sync();
assert!(!result.is_ok(), "parse error: {:?}", result);
}
#[test]
fn test_parse_valid_cloudwatch_describe_alarm_history() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"cloudwatch-describe-alarm-history.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client =
CloudWatchClient::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = DescribeAlarmHistoryInput::default();
let result = client.describe_alarm_history(request).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
fn test_parse_valid_cloudwatch_describe_alarms() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"cloudwatch-describe-alarms.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client =
CloudWatchClient::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = DescribeAlarmsInput::default();
let result = client.describe_alarms(request).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
fn test_parse_valid_cloudwatch_list_metrics() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"cloudwatch-list-metrics.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client =
CloudWatchClient::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = ListMetricsInput::default();
let result = client.list_metrics(request).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
}