use std::error::Error;
use std::fmt;
use async_trait::async_trait;
use rusoto_core::credential::ProvideAwsCredentials;
use rusoto_core::region;
use rusoto_core::request::{BufferedHttpResponse, DispatchSignedRequest};
use rusoto_core::{Client, RusotoError};
use rusoto_core::param::{Params, ServiceParams};
use rusoto_core::proto::xml::error::*;
use rusoto_core::proto::xml::util::{
self as xml_util, deserialize_elements, find_start_element, skip_tree,
};
use rusoto_core::proto::xml::util::{Next, Peek, XmlParseError, XmlResponse};
use rusoto_core::request::HttpResponse;
use rusoto_core::signature::SignedRequest;
#[cfg(feature = "deserialize_structs")]
use serde::Deserialize;
#[cfg(feature = "serialize_structs")]
use serde::Serialize;
use serde_urlencoded;
use std::str::FromStr;
use xml::EventReader;
impl CloudWatchClient {
fn new_params(&self, operation_name: &str) -> Params {
let mut params = Params::new();
params.put("Action", operation_name);
params.put("Version", "2010-08-01");
params
}
async fn sign_and_dispatch<E>(
&self,
request: SignedRequest,
from_response: fn(BufferedHttpResponse) -> RusotoError<E>,
) -> Result<HttpResponse, RusotoError<E>> {
let mut response = self.client.sign_and_dispatch(request).await?;
if !response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
return Err(from_response(response));
}
Ok(response)
}
}
#[allow(dead_code)]
struct ActionsEnabledDeserializer;
impl ActionsEnabledDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<bool, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, |s| Ok(bool::from_str(&s).unwrap()))
}
}
#[allow(dead_code)]
struct AlarmArnDeserializer;
impl AlarmArnDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct AlarmDescriptionDeserializer;
impl AlarmDescriptionDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct AlarmHistoryItem {
pub alarm_name: Option<String>,
pub alarm_type: Option<String>,
pub history_data: Option<String>,
pub history_item_type: Option<String>,
pub history_summary: Option<String>,
pub timestamp: Option<String>,
}
#[allow(dead_code)]
struct AlarmHistoryItemDeserializer;
impl AlarmHistoryItemDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<AlarmHistoryItem, XmlParseError> {
deserialize_elements::<_, AlarmHistoryItem, _>(tag_name, stack, |name, stack, obj| {
match name {
"AlarmName" => {
obj.alarm_name = Some(AlarmNameDeserializer::deserialize("AlarmName", stack)?);
}
"AlarmType" => {
obj.alarm_type = Some(AlarmTypeDeserializer::deserialize("AlarmType", stack)?);
}
"HistoryData" => {
obj.history_data =
Some(HistoryDataDeserializer::deserialize("HistoryData", stack)?);
}
"HistoryItemType" => {
obj.history_item_type = Some(HistoryItemTypeDeserializer::deserialize(
"HistoryItemType",
stack,
)?);
}
"HistorySummary" => {
obj.history_summary = Some(HistorySummaryDeserializer::deserialize(
"HistorySummary",
stack,
)?);
}
"Timestamp" => {
obj.timestamp = Some(TimestampDeserializer::deserialize("Timestamp", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[allow(dead_code)]
struct AlarmHistoryItemsDeserializer;
impl AlarmHistoryItemsDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<AlarmHistoryItem>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "member" {
obj.push(AlarmHistoryItemDeserializer::deserialize("member", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[allow(dead_code)]
struct AlarmNameDeserializer;
impl AlarmNameDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
struct 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);
}
}
}
#[allow(dead_code)]
struct AlarmRuleDeserializer;
impl AlarmRuleDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct AlarmTypeDeserializer;
impl AlarmTypeDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
struct AlarmTypesSerializer;
impl AlarmTypesSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.member.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct AnomalyDetector {
pub configuration: Option<AnomalyDetectorConfiguration>,
pub dimensions: Option<Vec<Dimension>>,
pub metric_name: Option<String>,
pub namespace: Option<String>,
pub stat: Option<String>,
pub state_value: Option<String>,
}
#[allow(dead_code)]
struct AnomalyDetectorDeserializer;
impl AnomalyDetectorDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<AnomalyDetector, XmlParseError> {
deserialize_elements::<_, AnomalyDetector, _>(tag_name, stack, |name, stack, obj| {
match name {
"Configuration" => {
obj.configuration =
Some(AnomalyDetectorConfigurationDeserializer::deserialize(
"Configuration",
stack,
)?);
}
"Dimensions" => {
obj.dimensions
.get_or_insert(vec![])
.extend(DimensionsDeserializer::deserialize("Dimensions", stack)?);
}
"MetricName" => {
obj.metric_name =
Some(MetricNameDeserializer::deserialize("MetricName", stack)?);
}
"Namespace" => {
obj.namespace = Some(NamespaceDeserializer::deserialize("Namespace", stack)?);
}
"Stat" => {
obj.stat = Some(AnomalyDetectorMetricStatDeserializer::deserialize(
"Stat", stack,
)?);
}
"StateValue" => {
obj.state_value = Some(AnomalyDetectorStateValueDeserializer::deserialize(
"StateValue",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AnomalyDetectorConfiguration {
pub excluded_time_ranges: Option<Vec<Range>>,
pub metric_timezone: Option<String>,
}
#[allow(dead_code)]
struct AnomalyDetectorConfigurationDeserializer;
impl AnomalyDetectorConfigurationDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<AnomalyDetectorConfiguration, XmlParseError> {
deserialize_elements::<_, AnomalyDetectorConfiguration, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"ExcludedTimeRanges" => {
obj.excluded_time_ranges.get_or_insert(vec![]).extend(
AnomalyDetectorExcludedTimeRangesDeserializer::deserialize(
"ExcludedTimeRanges",
stack,
)?,
);
}
"MetricTimezone" => {
obj.metric_timezone =
Some(AnomalyDetectorMetricTimezoneDeserializer::deserialize(
"MetricTimezone",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
struct AnomalyDetectorConfigurationSerializer;
impl AnomalyDetectorConfigurationSerializer {
fn serialize(params: &mut Params, name: &str, obj: &AnomalyDetectorConfiguration) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.excluded_time_ranges {
AnomalyDetectorExcludedTimeRangesSerializer::serialize(
params,
&format!("{}{}", prefix, "ExcludedTimeRanges"),
field_value,
);
}
if let Some(ref field_value) = obj.metric_timezone {
params.put(&format!("{}{}", prefix, "MetricTimezone"), &field_value);
}
}
}
#[allow(dead_code)]
struct AnomalyDetectorExcludedTimeRangesDeserializer;
impl AnomalyDetectorExcludedTimeRangesDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<Range>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "member" {
obj.push(RangeDeserializer::deserialize("member", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct AnomalyDetectorExcludedTimeRangesSerializer;
impl AnomalyDetectorExcludedTimeRangesSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<Range>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.member.{}", name, index + 1);
RangeSerializer::serialize(params, &key, obj);
}
}
}
#[allow(dead_code)]
struct AnomalyDetectorMetricStatDeserializer;
impl AnomalyDetectorMetricStatDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct AnomalyDetectorMetricTimezoneDeserializer;
impl AnomalyDetectorMetricTimezoneDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct AnomalyDetectorStateValueDeserializer;
impl AnomalyDetectorStateValueDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct AnomalyDetectorsDeserializer;
impl AnomalyDetectorsDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<AnomalyDetector>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "member" {
obj.push(AnomalyDetectorDeserializer::deserialize("member", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[allow(dead_code)]
struct BatchFailuresDeserializer;
impl BatchFailuresDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<PartialFailure>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "member" {
obj.push(PartialFailureDeserializer::deserialize("member", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[allow(dead_code)]
struct ComparisonOperatorDeserializer;
impl ComparisonOperatorDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct CompositeAlarm {
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 alarm_rule: Option<String>,
pub insufficient_data_actions: Option<Vec<String>>,
pub ok_actions: Option<Vec<String>>,
pub state_reason: Option<String>,
pub state_reason_data: Option<String>,
pub state_updated_timestamp: Option<String>,
pub state_value: Option<String>,
}
#[allow(dead_code)]
struct CompositeAlarmDeserializer;
impl CompositeAlarmDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CompositeAlarm, XmlParseError> {
deserialize_elements::<_, CompositeAlarm, _>(tag_name, stack, |name, stack, obj| {
match name {
"ActionsEnabled" => {
obj.actions_enabled = Some(ActionsEnabledDeserializer::deserialize(
"ActionsEnabled",
stack,
)?);
}
"AlarmActions" => {
obj.alarm_actions.get_or_insert(vec![]).extend(
ResourceListDeserializer::deserialize("AlarmActions", stack)?,
);
}
"AlarmArn" => {
obj.alarm_arn = Some(AlarmArnDeserializer::deserialize("AlarmArn", stack)?);
}
"AlarmConfigurationUpdatedTimestamp" => {
obj.alarm_configuration_updated_timestamp =
Some(TimestampDeserializer::deserialize(
"AlarmConfigurationUpdatedTimestamp",
stack,
)?);
}
"AlarmDescription" => {
obj.alarm_description = Some(AlarmDescriptionDeserializer::deserialize(
"AlarmDescription",
stack,
)?);
}
"AlarmName" => {
obj.alarm_name = Some(AlarmNameDeserializer::deserialize("AlarmName", stack)?);
}
"AlarmRule" => {
obj.alarm_rule = Some(AlarmRuleDeserializer::deserialize("AlarmRule", stack)?);
}
"InsufficientDataActions" => {
obj.insufficient_data_actions.get_or_insert(vec![]).extend(
ResourceListDeserializer::deserialize("InsufficientDataActions", stack)?,
);
}
"OKActions" => {
obj.ok_actions
.get_or_insert(vec![])
.extend(ResourceListDeserializer::deserialize("OKActions", stack)?);
}
"StateReason" => {
obj.state_reason =
Some(StateReasonDeserializer::deserialize("StateReason", stack)?);
}
"StateReasonData" => {
obj.state_reason_data = Some(StateReasonDataDeserializer::deserialize(
"StateReasonData",
stack,
)?);
}
"StateUpdatedTimestamp" => {
obj.state_updated_timestamp = Some(TimestampDeserializer::deserialize(
"StateUpdatedTimestamp",
stack,
)?);
}
"StateValue" => {
obj.state_value =
Some(StateValueDeserializer::deserialize("StateValue", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[allow(dead_code)]
struct CompositeAlarmsDeserializer;
impl CompositeAlarmsDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<CompositeAlarm>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "member" {
obj.push(CompositeAlarmDeserializer::deserialize("member", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct CountsSerializer;
impl CountsSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<f64>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.member.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
#[allow(dead_code)]
struct DashboardArnDeserializer;
impl DashboardArnDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct DashboardBodyDeserializer;
impl DashboardBodyDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct DashboardEntriesDeserializer;
impl DashboardEntriesDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<DashboardEntry>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "member" {
obj.push(DashboardEntryDeserializer::deserialize("member", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct DashboardEntry {
pub dashboard_arn: Option<String>,
pub dashboard_name: Option<String>,
pub last_modified: Option<String>,
pub size: Option<i64>,
}
#[allow(dead_code)]
struct DashboardEntryDeserializer;
impl DashboardEntryDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DashboardEntry, XmlParseError> {
deserialize_elements::<_, DashboardEntry, _>(tag_name, stack, |name, stack, obj| {
match name {
"DashboardArn" => {
obj.dashboard_arn = Some(DashboardArnDeserializer::deserialize(
"DashboardArn",
stack,
)?);
}
"DashboardName" => {
obj.dashboard_name = Some(DashboardNameDeserializer::deserialize(
"DashboardName",
stack,
)?);
}
"LastModified" => {
obj.last_modified = Some(LastModifiedDeserializer::deserialize(
"LastModified",
stack,
)?);
}
"Size" => {
obj.size = Some(SizeDeserializer::deserialize("Size", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[allow(dead_code)]
struct DashboardNameDeserializer;
impl DashboardNameDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
struct 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(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct DashboardValidationMessage {
pub data_path: Option<String>,
pub message: Option<String>,
}
#[allow(dead_code)]
struct DashboardValidationMessageDeserializer;
impl DashboardValidationMessageDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DashboardValidationMessage, XmlParseError> {
deserialize_elements::<_, DashboardValidationMessage, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"DataPath" => {
obj.data_path = Some(DataPathDeserializer::deserialize("DataPath", stack)?);
}
"Message" => {
obj.message = Some(MessageDeserializer::deserialize("Message", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[allow(dead_code)]
struct DashboardValidationMessagesDeserializer;
impl DashboardValidationMessagesDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<DashboardValidationMessage>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "member" {
obj.push(DashboardValidationMessageDeserializer::deserialize(
"member", stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[allow(dead_code)]
struct DataPathDeserializer;
impl DataPathDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct 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>,
}
#[allow(dead_code)]
struct DatapointDeserializer;
impl DatapointDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Datapoint, XmlParseError> {
deserialize_elements::<_, Datapoint, _>(tag_name, stack, |name, stack, obj| {
match name {
"Average" => {
obj.average = Some(DatapointValueDeserializer::deserialize("Average", stack)?);
}
"ExtendedStatistics" => {
obj.extended_statistics = Some(DatapointValueMapDeserializer::deserialize(
"ExtendedStatistics",
stack,
)?);
}
"Maximum" => {
obj.maximum = Some(DatapointValueDeserializer::deserialize("Maximum", stack)?);
}
"Minimum" => {
obj.minimum = Some(DatapointValueDeserializer::deserialize("Minimum", stack)?);
}
"SampleCount" => {
obj.sample_count = Some(DatapointValueDeserializer::deserialize(
"SampleCount",
stack,
)?);
}
"Sum" => {
obj.sum = Some(DatapointValueDeserializer::deserialize("Sum", stack)?);
}
"Timestamp" => {
obj.timestamp = Some(TimestampDeserializer::deserialize("Timestamp", stack)?);
}
"Unit" => {
obj.unit = Some(StandardUnitDeserializer::deserialize("Unit", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[allow(dead_code)]
struct DatapointValueDeserializer;
impl DatapointValueDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<f64, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, |s| Ok(f64::from_str(&s).unwrap()))
}
}
#[allow(dead_code)]
struct DatapointValueMapDeserializer;
impl DatapointValueMapDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<::std::collections::HashMap<String, f64>, XmlParseError> {
xml_util::start_element(tag_name, stack)?;
let mut obj = ::std::collections::HashMap::new();
while xml_util::peek_at_name(stack)? == "entry" {
xml_util::start_element("entry", stack)?;
let key = ExtendedStatisticDeserializer::deserialize("key", stack)?;
let value = DatapointValueDeserializer::deserialize("value", stack)?;
obj.insert(key, value);
xml_util::end_element("entry", stack)?;
}
xml_util::end_element(tag_name, stack)?;
Ok(obj)
}
}
#[allow(dead_code)]
struct DatapointValuesDeserializer;
impl DatapointValuesDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<f64>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "member" {
obj.push(DatapointValueDeserializer::deserialize("member", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[allow(dead_code)]
struct DatapointsDeserializer;
impl DatapointsDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<Datapoint>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "member" {
obj.push(DatapointDeserializer::deserialize("member", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[allow(dead_code)]
struct DatapointsToAlarmDeserializer;
impl DatapointsToAlarmDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<i64, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, |s| Ok(i64::from_str(&s).unwrap()))
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct 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(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteAnomalyDetectorInput {
pub dimensions: Option<Vec<Dimension>>,
pub metric_name: String,
pub namespace: String,
pub stat: String,
}
struct DeleteAnomalyDetectorInputSerializer;
impl DeleteAnomalyDetectorInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DeleteAnomalyDetectorInput) {
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);
params.put(&format!("{}{}", prefix, "Namespace"), &obj.namespace);
params.put(&format!("{}{}", prefix, "Stat"), &obj.stat);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct DeleteAnomalyDetectorOutput {}
#[allow(dead_code)]
struct DeleteAnomalyDetectorOutputDeserializer;
impl DeleteAnomalyDetectorOutputDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DeleteAnomalyDetectorOutput, XmlParseError> {
xml_util::start_element(tag_name, stack)?;
let obj = DeleteAnomalyDetectorOutput::default();
xml_util::end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
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(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct DeleteDashboardsOutput {}
#[allow(dead_code)]
struct DeleteDashboardsOutputDeserializer;
impl DeleteDashboardsOutputDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DeleteDashboardsOutput, XmlParseError> {
xml_util::start_element(tag_name, stack)?;
let obj = DeleteDashboardsOutput::default();
xml_util::end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteInsightRulesInput {
pub rule_names: Vec<String>,
}
struct DeleteInsightRulesInputSerializer;
impl DeleteInsightRulesInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DeleteInsightRulesInput) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
InsightRuleNamesSerializer::serialize(
params,
&format!("{}{}", prefix, "RuleNames"),
&obj.rule_names,
);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct DeleteInsightRulesOutput {
pub failures: Option<Vec<PartialFailure>>,
}
#[allow(dead_code)]
struct DeleteInsightRulesOutputDeserializer;
impl DeleteInsightRulesOutputDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DeleteInsightRulesOutput, XmlParseError> {
deserialize_elements::<_, DeleteInsightRulesOutput, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"Failures" => {
obj.failures
.get_or_insert(vec![])
.extend(BatchFailuresDeserializer::deserialize("Failures", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeAlarmHistoryInput {
pub alarm_name: Option<String>,
pub alarm_types: Option<Vec<String>>,
pub end_date: Option<String>,
pub history_item_type: Option<String>,
pub max_records: Option<i64>,
pub next_token: Option<String>,
pub scan_by: 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.alarm_types {
AlarmTypesSerializer::serialize(
params,
&format!("{}{}", prefix, "AlarmTypes"),
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);
}
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);
}
if let Some(ref field_value) = obj.start_date {
params.put(&format!("{}{}", prefix, "StartDate"), &field_value);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct DescribeAlarmHistoryOutput {
pub alarm_history_items: Option<Vec<AlarmHistoryItem>>,
pub next_token: Option<String>,
}
#[allow(dead_code)]
struct DescribeAlarmHistoryOutputDeserializer;
impl DescribeAlarmHistoryOutputDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeAlarmHistoryOutput, XmlParseError> {
deserialize_elements::<_, DescribeAlarmHistoryOutput, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"AlarmHistoryItems" => {
obj.alarm_history_items.get_or_insert(vec![]).extend(
AlarmHistoryItemsDeserializer::deserialize("AlarmHistoryItems", stack)?,
);
}
"NextToken" => {
obj.next_token =
Some(NextTokenDeserializer::deserialize("NextToken", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
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);
}
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(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct DescribeAlarmsForMetricOutput {
pub metric_alarms: Option<Vec<MetricAlarm>>,
}
#[allow(dead_code)]
struct DescribeAlarmsForMetricOutputDeserializer;
impl DescribeAlarmsForMetricOutputDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeAlarmsForMetricOutput, XmlParseError> {
deserialize_elements::<_, DescribeAlarmsForMetricOutput, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"MetricAlarms" => {
obj.metric_alarms.get_or_insert(vec![]).extend(
MetricAlarmsDeserializer::deserialize("MetricAlarms", stack)?,
);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeAlarmsInput {
pub action_prefix: Option<String>,
pub alarm_name_prefix: Option<String>,
pub alarm_names: Option<Vec<String>>,
pub alarm_types: Option<Vec<String>>,
pub children_of_alarm_name: Option<String>,
pub max_records: Option<i64>,
pub next_token: Option<String>,
pub parents_of_alarm_name: 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.alarm_types {
AlarmTypesSerializer::serialize(
params,
&format!("{}{}", prefix, "AlarmTypes"),
field_value,
);
}
if let Some(ref field_value) = obj.children_of_alarm_name {
params.put(
&format!("{}{}", prefix, "ChildrenOfAlarmName"),
&field_value,
);
}
if let Some(ref field_value) = obj.max_records {
params.put(&format!("{}{}", prefix, "MaxRecords"), &field_value);
}
if let Some(ref field_value) = obj.next_token {
params.put(&format!("{}{}", prefix, "NextToken"), &field_value);
}
if let Some(ref field_value) = obj.parents_of_alarm_name {
params.put(&format!("{}{}", prefix, "ParentsOfAlarmName"), &field_value);
}
if let Some(ref field_value) = obj.state_value {
params.put(&format!("{}{}", prefix, "StateValue"), &field_value);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct DescribeAlarmsOutput {
pub composite_alarms: Option<Vec<CompositeAlarm>>,
pub metric_alarms: Option<Vec<MetricAlarm>>,
pub next_token: Option<String>,
}
#[allow(dead_code)]
struct DescribeAlarmsOutputDeserializer;
impl DescribeAlarmsOutputDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeAlarmsOutput, XmlParseError> {
deserialize_elements::<_, DescribeAlarmsOutput, _>(tag_name, stack, |name, stack, obj| {
match name {
"CompositeAlarms" => {
obj.composite_alarms.get_or_insert(vec![]).extend(
CompositeAlarmsDeserializer::deserialize("CompositeAlarms", stack)?,
);
}
"MetricAlarms" => {
obj.metric_alarms.get_or_insert(vec![]).extend(
MetricAlarmsDeserializer::deserialize("MetricAlarms", stack)?,
);
}
"NextToken" => {
obj.next_token = Some(NextTokenDeserializer::deserialize("NextToken", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeAnomalyDetectorsInput {
pub dimensions: Option<Vec<Dimension>>,
pub max_results: Option<i64>,
pub metric_name: Option<String>,
pub namespace: Option<String>,
pub next_token: Option<String>,
}
struct DescribeAnomalyDetectorsInputSerializer;
impl DescribeAnomalyDetectorsInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeAnomalyDetectorsInput) {
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.max_results {
params.put(&format!("{}{}", prefix, "MaxResults"), &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(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct DescribeAnomalyDetectorsOutput {
pub anomaly_detectors: Option<Vec<AnomalyDetector>>,
pub next_token: Option<String>,
}
#[allow(dead_code)]
struct DescribeAnomalyDetectorsOutputDeserializer;
impl DescribeAnomalyDetectorsOutputDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeAnomalyDetectorsOutput, XmlParseError> {
deserialize_elements::<_, DescribeAnomalyDetectorsOutput, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"AnomalyDetectors" => {
obj.anomaly_detectors.get_or_insert(vec![]).extend(
AnomalyDetectorsDeserializer::deserialize("AnomalyDetectors", stack)?,
);
}
"NextToken" => {
obj.next_token =
Some(NextTokenDeserializer::deserialize("NextToken", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeInsightRulesInput {
pub max_results: Option<i64>,
pub next_token: Option<String>,
}
struct DescribeInsightRulesInputSerializer;
impl DescribeInsightRulesInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeInsightRulesInput) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.max_results {
params.put(&format!("{}{}", prefix, "MaxResults"), &field_value);
}
if let Some(ref field_value) = obj.next_token {
params.put(&format!("{}{}", prefix, "NextToken"), &field_value);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct DescribeInsightRulesOutput {
pub insight_rules: Option<Vec<InsightRule>>,
pub next_token: Option<String>,
}
#[allow(dead_code)]
struct DescribeInsightRulesOutputDeserializer;
impl DescribeInsightRulesOutputDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeInsightRulesOutput, XmlParseError> {
deserialize_elements::<_, DescribeInsightRulesOutput, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"InsightRules" => {
obj.insight_rules.get_or_insert(vec![]).extend(
InsightRulesDeserializer::deserialize("InsightRules", stack)?,
);
}
"NextToken" => {
obj.next_token =
Some(NextTokenDeserializer::deserialize("NextToken", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct Dimension {
pub name: String,
pub value: String,
}
#[allow(dead_code)]
struct DimensionDeserializer;
impl DimensionDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Dimension, XmlParseError> {
deserialize_elements::<_, Dimension, _>(tag_name, stack, |name, stack, obj| {
match name {
"Name" => {
obj.name = DimensionNameDeserializer::deserialize("Name", stack)?;
}
"Value" => {
obj.value = DimensionValueDeserializer::deserialize("Value", stack)?;
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
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(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
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);
}
}
}
#[allow(dead_code)]
struct DimensionNameDeserializer;
impl DimensionNameDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct DimensionValueDeserializer;
impl DimensionValueDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct DimensionsDeserializer;
impl DimensionsDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<Dimension>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "member" {
obj.push(DimensionDeserializer::deserialize("member", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
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(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
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(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DisableInsightRulesInput {
pub rule_names: Vec<String>,
}
struct DisableInsightRulesInputSerializer;
impl DisableInsightRulesInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DisableInsightRulesInput) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
InsightRuleNamesSerializer::serialize(
params,
&format!("{}{}", prefix, "RuleNames"),
&obj.rule_names,
);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct DisableInsightRulesOutput {
pub failures: Option<Vec<PartialFailure>>,
}
#[allow(dead_code)]
struct DisableInsightRulesOutputDeserializer;
impl DisableInsightRulesOutputDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DisableInsightRulesOutput, XmlParseError> {
deserialize_elements::<_, DisableInsightRulesOutput, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"Failures" => {
obj.failures
.get_or_insert(vec![])
.extend(BatchFailuresDeserializer::deserialize("Failures", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
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,
);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct EnableInsightRulesInput {
pub rule_names: Vec<String>,
}
struct EnableInsightRulesInputSerializer;
impl EnableInsightRulesInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &EnableInsightRulesInput) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
InsightRuleNamesSerializer::serialize(
params,
&format!("{}{}", prefix, "RuleNames"),
&obj.rule_names,
);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct EnableInsightRulesOutput {
pub failures: Option<Vec<PartialFailure>>,
}
#[allow(dead_code)]
struct EnableInsightRulesOutputDeserializer;
impl EnableInsightRulesOutputDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<EnableInsightRulesOutput, XmlParseError> {
deserialize_elements::<_, EnableInsightRulesOutput, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"Failures" => {
obj.failures
.get_or_insert(vec![])
.extend(BatchFailuresDeserializer::deserialize("Failures", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[allow(dead_code)]
struct EvaluateLowSampleCountPercentileDeserializer;
impl EvaluateLowSampleCountPercentileDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct EvaluationPeriodsDeserializer;
impl EvaluationPeriodsDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<i64, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, |s| Ok(i64::from_str(&s).unwrap()))
}
}
#[allow(dead_code)]
struct ExceptionTypeDeserializer;
impl ExceptionTypeDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct ExtendedStatisticDeserializer;
impl ExtendedStatisticDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
struct 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);
}
}
}
#[allow(dead_code)]
struct FailureCodeDeserializer;
impl FailureCodeDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct FailureDescriptionDeserializer;
impl FailureDescriptionDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct FailureResourceDeserializer;
impl FailureResourceDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct 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(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct GetDashboardOutput {
pub dashboard_arn: Option<String>,
pub dashboard_body: Option<String>,
pub dashboard_name: Option<String>,
}
#[allow(dead_code)]
struct GetDashboardOutputDeserializer;
impl GetDashboardOutputDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<GetDashboardOutput, XmlParseError> {
deserialize_elements::<_, GetDashboardOutput, _>(tag_name, stack, |name, stack, obj| {
match name {
"DashboardArn" => {
obj.dashboard_arn = Some(DashboardArnDeserializer::deserialize(
"DashboardArn",
stack,
)?);
}
"DashboardBody" => {
obj.dashboard_body = Some(DashboardBodyDeserializer::deserialize(
"DashboardBody",
stack,
)?);
}
"DashboardName" => {
obj.dashboard_name = Some(DashboardNameDeserializer::deserialize(
"DashboardName",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetInsightRuleReportInput {
pub end_time: String,
pub max_contributor_count: Option<i64>,
pub metrics: Option<Vec<String>>,
pub order_by: Option<String>,
pub period: i64,
pub rule_name: String,
pub start_time: String,
}
struct GetInsightRuleReportInputSerializer;
impl GetInsightRuleReportInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &GetInsightRuleReportInput) {
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_contributor_count {
params.put(
&format!("{}{}", prefix, "MaxContributorCount"),
&field_value,
);
}
if let Some(ref field_value) = obj.metrics {
InsightRuleMetricListSerializer::serialize(
params,
&format!("{}{}", prefix, "Metrics"),
field_value,
);
}
if let Some(ref field_value) = obj.order_by {
params.put(&format!("{}{}", prefix, "OrderBy"), &field_value);
}
params.put(&format!("{}{}", prefix, "Period"), &obj.period);
params.put(&format!("{}{}", prefix, "RuleName"), &obj.rule_name);
params.put(&format!("{}{}", prefix, "StartTime"), &obj.start_time);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct GetInsightRuleReportOutput {
pub aggregate_value: Option<f64>,
pub aggregation_statistic: Option<String>,
pub approximate_unique_count: Option<i64>,
pub contributors: Option<Vec<InsightRuleContributor>>,
pub key_labels: Option<Vec<String>>,
pub metric_datapoints: Option<Vec<InsightRuleMetricDatapoint>>,
}
#[allow(dead_code)]
struct GetInsightRuleReportOutputDeserializer;
impl GetInsightRuleReportOutputDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<GetInsightRuleReportOutput, XmlParseError> {
deserialize_elements::<_, GetInsightRuleReportOutput, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"AggregateValue" => {
obj.aggregate_value =
Some(InsightRuleUnboundDoubleDeserializer::deserialize(
"AggregateValue",
stack,
)?);
}
"AggregationStatistic" => {
obj.aggregation_statistic =
Some(InsightRuleAggregationStatisticDeserializer::deserialize(
"AggregationStatistic",
stack,
)?);
}
"ApproximateUniqueCount" => {
obj.approximate_unique_count =
Some(InsightRuleUnboundLongDeserializer::deserialize(
"ApproximateUniqueCount",
stack,
)?);
}
"Contributors" => {
obj.contributors.get_or_insert(vec![]).extend(
InsightRuleContributorsDeserializer::deserialize(
"Contributors",
stack,
)?,
);
}
"KeyLabels" => {
obj.key_labels.get_or_insert(vec![]).extend(
InsightRuleContributorKeyLabelsDeserializer::deserialize(
"KeyLabels",
stack,
)?,
);
}
"MetricDatapoints" => {
obj.metric_datapoints.get_or_insert(vec![]).extend(
InsightRuleMetricDatapointsDeserializer::deserialize(
"MetricDatapoints",
stack,
)?,
);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
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);
}
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(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct GetMetricDataOutput {
pub messages: Option<Vec<MessageData>>,
pub metric_data_results: Option<Vec<MetricDataResult>>,
pub next_token: Option<String>,
}
#[allow(dead_code)]
struct GetMetricDataOutputDeserializer;
impl GetMetricDataOutputDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<GetMetricDataOutput, XmlParseError> {
deserialize_elements::<_, GetMetricDataOutput, _>(tag_name, stack, |name, stack, obj| {
match name {
"Messages" => {
obj.messages.get_or_insert(vec![]).extend(
MetricDataResultMessagesDeserializer::deserialize("Messages", stack)?,
);
}
"MetricDataResults" => {
obj.metric_data_results.get_or_insert(vec![]).extend(
MetricDataResultsDeserializer::deserialize("MetricDataResults", stack)?,
);
}
"NextToken" => {
obj.next_token = Some(NextTokenDeserializer::deserialize("NextToken", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
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);
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(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct GetMetricStatisticsOutput {
pub datapoints: Option<Vec<Datapoint>>,
pub label: Option<String>,
}
#[allow(dead_code)]
struct GetMetricStatisticsOutputDeserializer;
impl GetMetricStatisticsOutputDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<GetMetricStatisticsOutput, XmlParseError> {
deserialize_elements::<_, GetMetricStatisticsOutput, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"Datapoints" => {
obj.datapoints
.get_or_insert(vec![])
.extend(DatapointsDeserializer::deserialize("Datapoints", stack)?);
}
"Label" => {
obj.label = Some(MetricLabelDeserializer::deserialize("Label", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetMetricWidgetImageInput {
pub metric_widget: String,
pub output_format: Option<String>,
}
struct GetMetricWidgetImageInputSerializer;
impl GetMetricWidgetImageInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &GetMetricWidgetImageInput) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(&format!("{}{}", prefix, "MetricWidget"), &obj.metric_widget);
if let Some(ref field_value) = obj.output_format {
params.put(&format!("{}{}", prefix, "OutputFormat"), &field_value);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct GetMetricWidgetImageOutput {
pub metric_widget_image: Option<bytes::Bytes>,
}
#[allow(dead_code)]
struct GetMetricWidgetImageOutputDeserializer;
impl GetMetricWidgetImageOutputDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<GetMetricWidgetImageOutput, XmlParseError> {
deserialize_elements::<_, GetMetricWidgetImageOutput, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"MetricWidgetImage" => {
obj.metric_widget_image = Some(MetricWidgetImageDeserializer::deserialize(
"MetricWidgetImage",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[allow(dead_code)]
struct HistoryDataDeserializer;
impl HistoryDataDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct HistoryItemTypeDeserializer;
impl HistoryItemTypeDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct HistorySummaryDeserializer;
impl HistorySummaryDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct InsightRule {
pub definition: String,
pub name: String,
pub schema: String,
pub state: String,
}
#[allow(dead_code)]
struct InsightRuleDeserializer;
impl InsightRuleDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<InsightRule, XmlParseError> {
deserialize_elements::<_, InsightRule, _>(tag_name, stack, |name, stack, obj| {
match name {
"Definition" => {
obj.definition =
InsightRuleDefinitionDeserializer::deserialize("Definition", stack)?;
}
"Name" => {
obj.name = InsightRuleNameDeserializer::deserialize("Name", stack)?;
}
"Schema" => {
obj.schema = InsightRuleSchemaDeserializer::deserialize("Schema", stack)?;
}
"State" => {
obj.state = InsightRuleStateDeserializer::deserialize("State", stack)?;
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[allow(dead_code)]
struct InsightRuleAggregationStatisticDeserializer;
impl InsightRuleAggregationStatisticDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct InsightRuleContributor {
pub approximate_aggregate_value: f64,
pub datapoints: Vec<InsightRuleContributorDatapoint>,
pub keys: Vec<String>,
}
#[allow(dead_code)]
struct InsightRuleContributorDeserializer;
impl InsightRuleContributorDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<InsightRuleContributor, XmlParseError> {
deserialize_elements::<_, InsightRuleContributor, _>(tag_name, stack, |name, stack, obj| {
match name {
"ApproximateAggregateValue" => {
obj.approximate_aggregate_value =
InsightRuleUnboundDoubleDeserializer::deserialize(
"ApproximateAggregateValue",
stack,
)?;
}
"Datapoints" => {
obj.datapoints.extend(
InsightRuleContributorDatapointsDeserializer::deserialize(
"Datapoints",
stack,
)?,
);
}
"Keys" => {
obj.keys
.extend(InsightRuleContributorKeysDeserializer::deserialize(
"Keys", stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct InsightRuleContributorDatapoint {
pub approximate_value: f64,
pub timestamp: String,
}
#[allow(dead_code)]
struct InsightRuleContributorDatapointDeserializer;
impl InsightRuleContributorDatapointDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<InsightRuleContributorDatapoint, XmlParseError> {
deserialize_elements::<_, InsightRuleContributorDatapoint, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"ApproximateValue" => {
obj.approximate_value = InsightRuleUnboundDoubleDeserializer::deserialize(
"ApproximateValue",
stack,
)?;
}
"Timestamp" => {
obj.timestamp = TimestampDeserializer::deserialize("Timestamp", stack)?;
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[allow(dead_code)]
struct InsightRuleContributorDatapointsDeserializer;
impl InsightRuleContributorDatapointsDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<InsightRuleContributorDatapoint>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "member" {
obj.push(InsightRuleContributorDatapointDeserializer::deserialize(
"member", stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[allow(dead_code)]
struct InsightRuleContributorKeyDeserializer;
impl InsightRuleContributorKeyDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct InsightRuleContributorKeyLabelDeserializer;
impl InsightRuleContributorKeyLabelDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct InsightRuleContributorKeyLabelsDeserializer;
impl InsightRuleContributorKeyLabelsDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<String>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "member" {
obj.push(InsightRuleContributorKeyLabelDeserializer::deserialize(
"member", stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[allow(dead_code)]
struct InsightRuleContributorKeysDeserializer;
impl InsightRuleContributorKeysDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<String>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "member" {
obj.push(InsightRuleContributorKeyDeserializer::deserialize(
"member", stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[allow(dead_code)]
struct InsightRuleContributorsDeserializer;
impl InsightRuleContributorsDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<InsightRuleContributor>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "member" {
obj.push(InsightRuleContributorDeserializer::deserialize(
"member", stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[allow(dead_code)]
struct InsightRuleDefinitionDeserializer;
impl InsightRuleDefinitionDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct InsightRuleMetricDatapoint {
pub average: Option<f64>,
pub max_contributor_value: Option<f64>,
pub maximum: Option<f64>,
pub minimum: Option<f64>,
pub sample_count: Option<f64>,
pub sum: Option<f64>,
pub timestamp: String,
pub unique_contributors: Option<f64>,
}
#[allow(dead_code)]
struct InsightRuleMetricDatapointDeserializer;
impl InsightRuleMetricDatapointDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<InsightRuleMetricDatapoint, XmlParseError> {
deserialize_elements::<_, InsightRuleMetricDatapoint, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"Average" => {
obj.average = Some(InsightRuleUnboundDoubleDeserializer::deserialize(
"Average", stack,
)?);
}
"MaxContributorValue" => {
obj.max_contributor_value =
Some(InsightRuleUnboundDoubleDeserializer::deserialize(
"MaxContributorValue",
stack,
)?);
}
"Maximum" => {
obj.maximum = Some(InsightRuleUnboundDoubleDeserializer::deserialize(
"Maximum", stack,
)?);
}
"Minimum" => {
obj.minimum = Some(InsightRuleUnboundDoubleDeserializer::deserialize(
"Minimum", stack,
)?);
}
"SampleCount" => {
obj.sample_count = Some(InsightRuleUnboundDoubleDeserializer::deserialize(
"SampleCount",
stack,
)?);
}
"Sum" => {
obj.sum = Some(InsightRuleUnboundDoubleDeserializer::deserialize(
"Sum", stack,
)?);
}
"Timestamp" => {
obj.timestamp = TimestampDeserializer::deserialize("Timestamp", stack)?;
}
"UniqueContributors" => {
obj.unique_contributors =
Some(InsightRuleUnboundDoubleDeserializer::deserialize(
"UniqueContributors",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[allow(dead_code)]
struct InsightRuleMetricDatapointsDeserializer;
impl InsightRuleMetricDatapointsDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<InsightRuleMetricDatapoint>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "member" {
obj.push(InsightRuleMetricDatapointDeserializer::deserialize(
"member", stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct InsightRuleMetricListSerializer;
impl InsightRuleMetricListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.member.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
#[allow(dead_code)]
struct InsightRuleNameDeserializer;
impl InsightRuleNameDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
struct InsightRuleNamesSerializer;
impl InsightRuleNamesSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.member.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
#[allow(dead_code)]
struct InsightRuleSchemaDeserializer;
impl InsightRuleSchemaDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct InsightRuleStateDeserializer;
impl InsightRuleStateDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct InsightRuleUnboundDoubleDeserializer;
impl InsightRuleUnboundDoubleDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<f64, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, |s| Ok(f64::from_str(&s).unwrap()))
}
}
#[allow(dead_code)]
struct InsightRuleUnboundLongDeserializer;
impl InsightRuleUnboundLongDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<i64, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, |s| Ok(i64::from_str(&s).unwrap()))
}
}
#[allow(dead_code)]
struct InsightRulesDeserializer;
impl InsightRulesDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<InsightRule>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "member" {
obj.push(InsightRuleDeserializer::deserialize("member", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[allow(dead_code)]
struct LastModifiedDeserializer;
impl LastModifiedDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct 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(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct ListDashboardsOutput {
pub dashboard_entries: Option<Vec<DashboardEntry>>,
pub next_token: Option<String>,
}
#[allow(dead_code)]
struct ListDashboardsOutputDeserializer;
impl ListDashboardsOutputDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ListDashboardsOutput, XmlParseError> {
deserialize_elements::<_, ListDashboardsOutput, _>(tag_name, stack, |name, stack, obj| {
match name {
"DashboardEntries" => {
obj.dashboard_entries.get_or_insert(vec![]).extend(
DashboardEntriesDeserializer::deserialize("DashboardEntries", stack)?,
);
}
"NextToken" => {
obj.next_token = Some(NextTokenDeserializer::deserialize("NextToken", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
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(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct ListMetricsOutput {
pub metrics: Option<Vec<Metric>>,
pub next_token: Option<String>,
}
#[allow(dead_code)]
struct ListMetricsOutputDeserializer;
impl ListMetricsOutputDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ListMetricsOutput, XmlParseError> {
deserialize_elements::<_, ListMetricsOutput, _>(tag_name, stack, |name, stack, obj| {
match name {
"Metrics" => {
obj.metrics
.get_or_insert(vec![])
.extend(MetricsDeserializer::deserialize("Metrics", stack)?);
}
"NextToken" => {
obj.next_token = Some(NextTokenDeserializer::deserialize("NextToken", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListTagsForResourceInput {
pub resource_arn: String,
}
struct ListTagsForResourceInputSerializer;
impl ListTagsForResourceInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ListTagsForResourceInput) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(&format!("{}{}", prefix, "ResourceARN"), &obj.resource_arn);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct ListTagsForResourceOutput {
pub tags: Option<Vec<Tag>>,
}
#[allow(dead_code)]
struct ListTagsForResourceOutputDeserializer;
impl ListTagsForResourceOutputDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ListTagsForResourceOutput, XmlParseError> {
deserialize_elements::<_, ListTagsForResourceOutput, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"Tags" => {
obj.tags
.get_or_insert(vec![])
.extend(TagListDeserializer::deserialize("Tags", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[allow(dead_code)]
struct MessageDeserializer;
impl MessageDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct MessageData {
pub code: Option<String>,
pub value: Option<String>,
}
#[allow(dead_code)]
struct MessageDataDeserializer;
impl MessageDataDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<MessageData, XmlParseError> {
deserialize_elements::<_, MessageData, _>(tag_name, stack, |name, stack, obj| {
match name {
"Code" => {
obj.code = Some(MessageDataCodeDeserializer::deserialize("Code", stack)?);
}
"Value" => {
obj.value = Some(MessageDataValueDeserializer::deserialize("Value", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[allow(dead_code)]
struct MessageDataCodeDeserializer;
impl MessageDataCodeDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct MessageDataValueDeserializer;
impl MessageDataValueDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct Metric {
pub dimensions: Option<Vec<Dimension>>,
pub metric_name: Option<String>,
pub namespace: Option<String>,
}
#[allow(dead_code)]
struct MetricDeserializer;
impl MetricDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<Metric, XmlParseError> {
deserialize_elements::<_, Metric, _>(tag_name, stack, |name, stack, obj| {
match name {
"Dimensions" => {
obj.dimensions
.get_or_insert(vec![])
.extend(DimensionsDeserializer::deserialize("Dimensions", stack)?);
}
"MetricName" => {
obj.metric_name =
Some(MetricNameDeserializer::deserialize("MetricName", stack)?);
}
"Namespace" => {
obj.namespace = Some(NamespaceDeserializer::deserialize("Namespace", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
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(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
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 metrics: Option<Vec<MetricDataQuery>>,
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 threshold_metric_id: Option<String>,
pub treat_missing_data: Option<String>,
pub unit: Option<String>,
}
#[allow(dead_code)]
struct MetricAlarmDeserializer;
impl MetricAlarmDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<MetricAlarm, XmlParseError> {
deserialize_elements::<_, MetricAlarm, _>(tag_name, stack, |name, stack, obj| {
match name {
"ActionsEnabled" => {
obj.actions_enabled = Some(ActionsEnabledDeserializer::deserialize(
"ActionsEnabled",
stack,
)?);
}
"AlarmActions" => {
obj.alarm_actions.get_or_insert(vec![]).extend(
ResourceListDeserializer::deserialize("AlarmActions", stack)?,
);
}
"AlarmArn" => {
obj.alarm_arn = Some(AlarmArnDeserializer::deserialize("AlarmArn", stack)?);
}
"AlarmConfigurationUpdatedTimestamp" => {
obj.alarm_configuration_updated_timestamp =
Some(TimestampDeserializer::deserialize(
"AlarmConfigurationUpdatedTimestamp",
stack,
)?);
}
"AlarmDescription" => {
obj.alarm_description = Some(AlarmDescriptionDeserializer::deserialize(
"AlarmDescription",
stack,
)?);
}
"AlarmName" => {
obj.alarm_name = Some(AlarmNameDeserializer::deserialize("AlarmName", stack)?);
}
"ComparisonOperator" => {
obj.comparison_operator = Some(ComparisonOperatorDeserializer::deserialize(
"ComparisonOperator",
stack,
)?);
}
"DatapointsToAlarm" => {
obj.datapoints_to_alarm = Some(DatapointsToAlarmDeserializer::deserialize(
"DatapointsToAlarm",
stack,
)?);
}
"Dimensions" => {
obj.dimensions
.get_or_insert(vec![])
.extend(DimensionsDeserializer::deserialize("Dimensions", stack)?);
}
"EvaluateLowSampleCountPercentile" => {
obj.evaluate_low_sample_count_percentile =
Some(EvaluateLowSampleCountPercentileDeserializer::deserialize(
"EvaluateLowSampleCountPercentile",
stack,
)?);
}
"EvaluationPeriods" => {
obj.evaluation_periods = Some(EvaluationPeriodsDeserializer::deserialize(
"EvaluationPeriods",
stack,
)?);
}
"ExtendedStatistic" => {
obj.extended_statistic = Some(ExtendedStatisticDeserializer::deserialize(
"ExtendedStatistic",
stack,
)?);
}
"InsufficientDataActions" => {
obj.insufficient_data_actions.get_or_insert(vec![]).extend(
ResourceListDeserializer::deserialize("InsufficientDataActions", stack)?,
);
}
"MetricName" => {
obj.metric_name =
Some(MetricNameDeserializer::deserialize("MetricName", stack)?);
}
"Metrics" => {
obj.metrics.get_or_insert(vec![]).extend(
MetricDataQueriesDeserializer::deserialize("Metrics", stack)?,
);
}
"Namespace" => {
obj.namespace = Some(NamespaceDeserializer::deserialize("Namespace", stack)?);
}
"OKActions" => {
obj.ok_actions
.get_or_insert(vec![])
.extend(ResourceListDeserializer::deserialize("OKActions", stack)?);
}
"Period" => {
obj.period = Some(PeriodDeserializer::deserialize("Period", stack)?);
}
"StateReason" => {
obj.state_reason =
Some(StateReasonDeserializer::deserialize("StateReason", stack)?);
}
"StateReasonData" => {
obj.state_reason_data = Some(StateReasonDataDeserializer::deserialize(
"StateReasonData",
stack,
)?);
}
"StateUpdatedTimestamp" => {
obj.state_updated_timestamp = Some(TimestampDeserializer::deserialize(
"StateUpdatedTimestamp",
stack,
)?);
}
"StateValue" => {
obj.state_value =
Some(StateValueDeserializer::deserialize("StateValue", stack)?);
}
"Statistic" => {
obj.statistic = Some(StatisticDeserializer::deserialize("Statistic", stack)?);
}
"Threshold" => {
obj.threshold = Some(ThresholdDeserializer::deserialize("Threshold", stack)?);
}
"ThresholdMetricId" => {
obj.threshold_metric_id = Some(MetricIdDeserializer::deserialize(
"ThresholdMetricId",
stack,
)?);
}
"TreatMissingData" => {
obj.treat_missing_data = Some(TreatMissingDataDeserializer::deserialize(
"TreatMissingData",
stack,
)?);
}
"Unit" => {
obj.unit = Some(StandardUnitDeserializer::deserialize("Unit", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[allow(dead_code)]
struct MetricAlarmsDeserializer;
impl MetricAlarmsDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<MetricAlarm>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "member" {
obj.push(MetricAlarmDeserializer::deserialize("member", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
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);
}
}
}
#[allow(dead_code)]
struct MetricDataQueriesDeserializer;
impl MetricDataQueriesDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<MetricDataQuery>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "member" {
obj.push(MetricDataQueryDeserializer::deserialize("member", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
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(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct MetricDataQuery {
pub expression: Option<String>,
pub id: String,
pub label: Option<String>,
pub metric_stat: Option<MetricStat>,
pub period: Option<i64>,
pub return_data: Option<bool>,
}
#[allow(dead_code)]
struct MetricDataQueryDeserializer;
impl MetricDataQueryDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<MetricDataQuery, XmlParseError> {
deserialize_elements::<_, MetricDataQuery, _>(tag_name, stack, |name, stack, obj| {
match name {
"Expression" => {
obj.expression = Some(MetricExpressionDeserializer::deserialize(
"Expression",
stack,
)?);
}
"Id" => {
obj.id = MetricIdDeserializer::deserialize("Id", stack)?;
}
"Label" => {
obj.label = Some(MetricLabelDeserializer::deserialize("Label", stack)?);
}
"MetricStat" => {
obj.metric_stat =
Some(MetricStatDeserializer::deserialize("MetricStat", stack)?);
}
"Period" => {
obj.period = Some(PeriodDeserializer::deserialize("Period", stack)?);
}
"ReturnData" => {
obj.return_data =
Some(ReturnDataDeserializer::deserialize("ReturnData", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
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.period {
params.put(&format!("{}{}", prefix, "Period"), &field_value);
}
if let Some(ref field_value) = obj.return_data {
params.put(&format!("{}{}", prefix, "ReturnData"), &field_value);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
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>>,
}
#[allow(dead_code)]
struct MetricDataResultDeserializer;
impl MetricDataResultDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<MetricDataResult, XmlParseError> {
deserialize_elements::<_, MetricDataResult, _>(tag_name, stack, |name, stack, obj| {
match name {
"Id" => {
obj.id = Some(MetricIdDeserializer::deserialize("Id", stack)?);
}
"Label" => {
obj.label = Some(MetricLabelDeserializer::deserialize("Label", stack)?);
}
"Messages" => {
obj.messages.get_or_insert(vec![]).extend(
MetricDataResultMessagesDeserializer::deserialize("Messages", stack)?,
);
}
"StatusCode" => {
obj.status_code =
Some(StatusCodeDeserializer::deserialize("StatusCode", stack)?);
}
"Timestamps" => {
obj.timestamps
.get_or_insert(vec![])
.extend(TimestampsDeserializer::deserialize("Timestamps", stack)?);
}
"Values" => {
obj.values
.get_or_insert(vec![])
.extend(DatapointValuesDeserializer::deserialize("Values", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[allow(dead_code)]
struct MetricDataResultMessagesDeserializer;
impl MetricDataResultMessagesDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<MessageData>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "member" {
obj.push(MessageDataDeserializer::deserialize("member", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[allow(dead_code)]
struct MetricDataResultsDeserializer;
impl MetricDataResultsDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<MetricDataResult>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "member" {
obj.push(MetricDataResultDeserializer::deserialize("member", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct MetricDatum {
pub counts: Option<Vec<f64>>,
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>,
pub values: Option<Vec<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.counts {
CountsSerializer::serialize(params, &format!("{}{}", prefix, "Counts"), field_value);
}
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);
}
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);
}
if let Some(ref field_value) = obj.values {
ValuesSerializer::serialize(params, &format!("{}{}", prefix, "Values"), field_value);
}
}
}
#[allow(dead_code)]
struct MetricExpressionDeserializer;
impl MetricExpressionDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct MetricIdDeserializer;
impl MetricIdDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct MetricLabelDeserializer;
impl MetricLabelDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct MetricNameDeserializer;
impl MetricNameDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct MetricStat {
pub metric: Metric,
pub period: i64,
pub stat: String,
pub unit: Option<String>,
}
#[allow(dead_code)]
struct MetricStatDeserializer;
impl MetricStatDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<MetricStat, XmlParseError> {
deserialize_elements::<_, MetricStat, _>(tag_name, stack, |name, stack, obj| {
match name {
"Metric" => {
obj.metric = MetricDeserializer::deserialize("Metric", stack)?;
}
"Period" => {
obj.period = PeriodDeserializer::deserialize("Period", stack)?;
}
"Stat" => {
obj.stat = StatDeserializer::deserialize("Stat", stack)?;
}
"Unit" => {
obj.unit = Some(StandardUnitDeserializer::deserialize("Unit", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
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);
params.put(&format!("{}{}", prefix, "Stat"), &obj.stat);
if let Some(ref field_value) = obj.unit {
params.put(&format!("{}{}", prefix, "Unit"), &field_value);
}
}
}
#[allow(dead_code)]
struct MetricWidgetImageDeserializer;
impl MetricWidgetImageDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<bytes::Bytes, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, |s| Ok(s.into()))
}
}
#[allow(dead_code)]
struct MetricsDeserializer;
impl MetricsDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<Metric>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "member" {
obj.push(MetricDeserializer::deserialize("member", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[allow(dead_code)]
struct NamespaceDeserializer;
impl NamespaceDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct NextTokenDeserializer;
impl NextTokenDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct PartialFailure {
pub exception_type: Option<String>,
pub failure_code: Option<String>,
pub failure_description: Option<String>,
pub failure_resource: Option<String>,
}
#[allow(dead_code)]
struct PartialFailureDeserializer;
impl PartialFailureDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<PartialFailure, XmlParseError> {
deserialize_elements::<_, PartialFailure, _>(tag_name, stack, |name, stack, obj| {
match name {
"ExceptionType" => {
obj.exception_type = Some(ExceptionTypeDeserializer::deserialize(
"ExceptionType",
stack,
)?);
}
"FailureCode" => {
obj.failure_code =
Some(FailureCodeDeserializer::deserialize("FailureCode", stack)?);
}
"FailureDescription" => {
obj.failure_description = Some(FailureDescriptionDeserializer::deserialize(
"FailureDescription",
stack,
)?);
}
"FailureResource" => {
obj.failure_resource = Some(FailureResourceDeserializer::deserialize(
"FailureResource",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[allow(dead_code)]
struct PeriodDeserializer;
impl PeriodDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<i64, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, |s| Ok(i64::from_str(&s).unwrap()))
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct PutAnomalyDetectorInput {
pub configuration: Option<AnomalyDetectorConfiguration>,
pub dimensions: Option<Vec<Dimension>>,
pub metric_name: String,
pub namespace: String,
pub stat: String,
}
struct PutAnomalyDetectorInputSerializer;
impl PutAnomalyDetectorInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &PutAnomalyDetectorInput) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.configuration {
AnomalyDetectorConfigurationSerializer::serialize(
params,
&format!("{}{}", prefix, "Configuration"),
field_value,
);
}
if let Some(ref field_value) = obj.dimensions {
DimensionsSerializer::serialize(
params,
&format!("{}{}", prefix, "Dimensions"),
field_value,
);
}
params.put(&format!("{}{}", prefix, "MetricName"), &obj.metric_name);
params.put(&format!("{}{}", prefix, "Namespace"), &obj.namespace);
params.put(&format!("{}{}", prefix, "Stat"), &obj.stat);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct PutAnomalyDetectorOutput {}
#[allow(dead_code)]
struct PutAnomalyDetectorOutputDeserializer;
impl PutAnomalyDetectorOutputDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<PutAnomalyDetectorOutput, XmlParseError> {
xml_util::start_element(tag_name, stack)?;
let obj = PutAnomalyDetectorOutput::default();
xml_util::end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct PutCompositeAlarmInput {
pub actions_enabled: Option<bool>,
pub alarm_actions: Option<Vec<String>>,
pub alarm_description: Option<String>,
pub alarm_name: String,
pub alarm_rule: String,
pub insufficient_data_actions: Option<Vec<String>>,
pub ok_actions: Option<Vec<String>>,
pub tags: Option<Vec<Tag>>,
}
struct PutCompositeAlarmInputSerializer;
impl PutCompositeAlarmInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &PutCompositeAlarmInput) {
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);
}
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, "AlarmRule"), &obj.alarm_rule);
if let Some(ref field_value) = obj.insufficient_data_actions {
ResourceListSerializer::serialize(
params,
&format!("{}{}", prefix, "InsufficientDataActions"),
field_value,
);
}
if let Some(ref field_value) = obj.ok_actions {
ResourceListSerializer::serialize(
params,
&format!("{}{}", prefix, "OKActions"),
field_value,
);
}
if let Some(ref field_value) = obj.tags {
TagListSerializer::serialize(params, &format!("{}{}", prefix, "Tags"), field_value);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
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(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct PutDashboardOutput {
pub dashboard_validation_messages: Option<Vec<DashboardValidationMessage>>,
}
#[allow(dead_code)]
struct PutDashboardOutputDeserializer;
impl PutDashboardOutputDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<PutDashboardOutput, XmlParseError> {
deserialize_elements::<_, PutDashboardOutput, _>(tag_name, stack, |name, stack, obj| {
match name {
"DashboardValidationMessages" => {
obj.dashboard_validation_messages
.get_or_insert(vec![])
.extend(DashboardValidationMessagesDeserializer::deserialize(
"DashboardValidationMessages",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct PutInsightRuleInput {
pub rule_definition: String,
pub rule_name: String,
pub rule_state: Option<String>,
pub tags: Option<Vec<Tag>>,
}
struct PutInsightRuleInputSerializer;
impl PutInsightRuleInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &PutInsightRuleInput) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "RuleDefinition"),
&obj.rule_definition,
);
params.put(&format!("{}{}", prefix, "RuleName"), &obj.rule_name);
if let Some(ref field_value) = obj.rule_state {
params.put(&format!("{}{}", prefix, "RuleState"), &field_value);
}
if let Some(ref field_value) = obj.tags {
TagListSerializer::serialize(params, &format!("{}{}", prefix, "Tags"), field_value);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct PutInsightRuleOutput {}
#[allow(dead_code)]
struct PutInsightRuleOutputDeserializer;
impl PutInsightRuleOutputDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<PutInsightRuleOutput, XmlParseError> {
xml_util::start_element(tag_name, stack)?;
let obj = PutInsightRuleOutput::default();
xml_util::end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
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: Option<String>,
pub metrics: Option<Vec<MetricDataQuery>>,
pub namespace: Option<String>,
pub ok_actions: Option<Vec<String>>,
pub period: Option<i64>,
pub statistic: Option<String>,
pub tags: Option<Vec<Tag>>,
pub threshold: Option<f64>,
pub threshold_metric_id: Option<String>,
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);
}
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);
}
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,
);
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,
);
}
if let Some(ref field_value) = obj.metric_name {
params.put(&format!("{}{}", prefix, "MetricName"), &field_value);
}
if let Some(ref field_value) = obj.metrics {
MetricDataQueriesSerializer::serialize(
params,
&format!("{}{}", prefix, "Metrics"),
field_value,
);
}
if let Some(ref field_value) = obj.namespace {
params.put(&format!("{}{}", prefix, "Namespace"), &field_value);
}
if let Some(ref field_value) = obj.ok_actions {
ResourceListSerializer::serialize(
params,
&format!("{}{}", prefix, "OKActions"),
field_value,
);
}
if let Some(ref field_value) = obj.period {
params.put(&format!("{}{}", prefix, "Period"), &field_value);
}
if let Some(ref field_value) = obj.statistic {
params.put(&format!("{}{}", prefix, "Statistic"), &field_value);
}
if let Some(ref field_value) = obj.tags {
TagListSerializer::serialize(params, &format!("{}{}", prefix, "Tags"), field_value);
}
if let Some(ref field_value) = obj.threshold {
params.put(&format!("{}{}", prefix, "Threshold"), &field_value);
}
if let Some(ref field_value) = obj.threshold_metric_id {
params.put(&format!("{}{}", prefix, "ThresholdMetricId"), &field_value);
}
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(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
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);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct Range {
pub end_time: String,
pub start_time: String,
}
#[allow(dead_code)]
struct RangeDeserializer;
impl RangeDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<Range, XmlParseError> {
deserialize_elements::<_, Range, _>(tag_name, stack, |name, stack, obj| {
match name {
"EndTime" => {
obj.end_time = TimestampDeserializer::deserialize("EndTime", stack)?;
}
"StartTime" => {
obj.start_time = TimestampDeserializer::deserialize("StartTime", stack)?;
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct RangeSerializer;
impl RangeSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Range) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(&format!("{}{}", prefix, "EndTime"), &obj.end_time);
params.put(&format!("{}{}", prefix, "StartTime"), &obj.start_time);
}
}
#[allow(dead_code)]
struct ResourceListDeserializer;
impl ResourceListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<String>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "member" {
obj.push(ResourceNameDeserializer::deserialize("member", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
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);
}
}
}
#[allow(dead_code)]
struct ResourceNameDeserializer;
impl ResourceNameDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct ReturnDataDeserializer;
impl ReturnDataDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<bool, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, |s| Ok(bool::from_str(&s).unwrap()))
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct 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);
}
}
#[allow(dead_code)]
struct SizeDeserializer;
impl SizeDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<i64, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, |s| Ok(i64::from_str(&s).unwrap()))
}
}
#[allow(dead_code)]
struct StandardUnitDeserializer;
impl StandardUnitDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct StatDeserializer;
impl StatDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct StateReasonDeserializer;
impl StateReasonDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct StateReasonDataDeserializer;
impl StateReasonDataDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct StateValueDeserializer;
impl StateValueDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct StatisticDeserializer;
impl StatisticDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct 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);
params.put(&format!("{}{}", prefix, "Minimum"), &obj.minimum);
params.put(&format!("{}{}", prefix, "SampleCount"), &obj.sample_count);
params.put(&format!("{}{}", prefix, "Sum"), &obj.sum);
}
}
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);
}
}
}
#[allow(dead_code)]
struct StatusCodeDeserializer;
impl StatusCodeDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct Tag {
pub key: String,
pub value: String,
}
#[allow(dead_code)]
struct TagDeserializer;
impl TagDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<Tag, XmlParseError> {
deserialize_elements::<_, Tag, _>(tag_name, stack, |name, stack, obj| {
match name {
"Key" => {
obj.key = TagKeyDeserializer::deserialize("Key", stack)?;
}
"Value" => {
obj.value = TagValueDeserializer::deserialize("Value", stack)?;
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct TagSerializer;
impl TagSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Tag) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(&format!("{}{}", prefix, "Key"), &obj.key);
params.put(&format!("{}{}", prefix, "Value"), &obj.value);
}
}
#[allow(dead_code)]
struct TagKeyDeserializer;
impl TagKeyDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
struct TagKeyListSerializer;
impl TagKeyListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.member.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
#[allow(dead_code)]
struct TagListDeserializer;
impl TagListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<Tag>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "member" {
obj.push(TagDeserializer::deserialize("member", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct TagListSerializer;
impl TagListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<Tag>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.member.{}", name, index + 1);
TagSerializer::serialize(params, &key, obj);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct TagResourceInput {
pub resource_arn: String,
pub tags: Vec<Tag>,
}
struct TagResourceInputSerializer;
impl TagResourceInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &TagResourceInput) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(&format!("{}{}", prefix, "ResourceARN"), &obj.resource_arn);
TagListSerializer::serialize(params, &format!("{}{}", prefix, "Tags"), &obj.tags);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct TagResourceOutput {}
#[allow(dead_code)]
struct TagResourceOutputDeserializer;
impl TagResourceOutputDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<TagResourceOutput, XmlParseError> {
xml_util::start_element(tag_name, stack)?;
let obj = TagResourceOutput::default();
xml_util::end_element(tag_name, stack)?;
Ok(obj)
}
}
#[allow(dead_code)]
struct TagValueDeserializer;
impl TagValueDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct ThresholdDeserializer;
impl ThresholdDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<f64, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, |s| Ok(f64::from_str(&s).unwrap()))
}
}
#[allow(dead_code)]
struct TimestampDeserializer;
impl TimestampDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct TimestampsDeserializer;
impl TimestampsDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<String>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "member" {
obj.push(TimestampDeserializer::deserialize("member", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[allow(dead_code)]
struct TreatMissingDataDeserializer;
impl TreatMissingDataDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UntagResourceInput {
pub resource_arn: String,
pub tag_keys: Vec<String>,
}
struct UntagResourceInputSerializer;
impl UntagResourceInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &UntagResourceInput) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(&format!("{}{}", prefix, "ResourceARN"), &obj.resource_arn);
TagKeyListSerializer::serialize(params, &format!("{}{}", prefix, "TagKeys"), &obj.tag_keys);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct UntagResourceOutput {}
#[allow(dead_code)]
struct UntagResourceOutputDeserializer;
impl UntagResourceOutputDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<UntagResourceOutput, XmlParseError> {
xml_util::start_element(tag_name, stack)?;
let obj = UntagResourceOutput::default();
xml_util::end_element(tag_name, stack)?;
Ok(obj)
}
}
struct ValuesSerializer;
impl ValuesSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<f64>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.member.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteAlarmsError {
ResourceNotFound(String),
}
impl DeleteAlarmsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteAlarmsError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"ResourceNotFound" => {
return RusotoError::Service(DeleteAlarmsError::ResourceNotFound(
parsed_error.message,
))
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DeleteAlarmsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteAlarmsError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteAlarmsError {}
#[derive(Debug, PartialEq)]
pub enum DeleteAnomalyDetectorError {
InternalServiceFault(String),
InvalidParameterValue(String),
MissingRequiredParameter(String),
ResourceNotFound(String),
}
impl DeleteAnomalyDetectorError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteAnomalyDetectorError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"InternalServiceError" => {
return RusotoError::Service(
DeleteAnomalyDetectorError::InternalServiceFault(parsed_error.message),
)
}
"InvalidParameterValue" => {
return RusotoError::Service(
DeleteAnomalyDetectorError::InvalidParameterValue(parsed_error.message),
)
}
"MissingParameter" => {
return RusotoError::Service(
DeleteAnomalyDetectorError::MissingRequiredParameter(
parsed_error.message,
),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(DeleteAnomalyDetectorError::ResourceNotFound(
parsed_error.message,
))
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DeleteAnomalyDetectorError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteAnomalyDetectorError::InternalServiceFault(ref cause) => write!(f, "{}", cause),
DeleteAnomalyDetectorError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
DeleteAnomalyDetectorError::MissingRequiredParameter(ref cause) => {
write!(f, "{}", cause)
}
DeleteAnomalyDetectorError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteAnomalyDetectorError {}
#[derive(Debug, PartialEq)]
pub enum DeleteDashboardsError {
DashboardNotFoundError(String),
InternalServiceFault(String),
InvalidParameterValue(String),
}
impl DeleteDashboardsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteDashboardsError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"ResourceNotFound" => {
return RusotoError::Service(DeleteDashboardsError::DashboardNotFoundError(
parsed_error.message,
))
}
"InternalServiceError" => {
return RusotoError::Service(DeleteDashboardsError::InternalServiceFault(
parsed_error.message,
))
}
"InvalidParameterValue" => {
return RusotoError::Service(DeleteDashboardsError::InvalidParameterValue(
parsed_error.message,
))
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DeleteDashboardsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteDashboardsError::DashboardNotFoundError(ref cause) => write!(f, "{}", cause),
DeleteDashboardsError::InternalServiceFault(ref cause) => write!(f, "{}", cause),
DeleteDashboardsError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteDashboardsError {}
#[derive(Debug, PartialEq)]
pub enum DeleteInsightRulesError {
InvalidParameterValue(String),
MissingRequiredParameter(String),
}
impl DeleteInsightRulesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteInsightRulesError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"InvalidParameterValue" => {
return RusotoError::Service(
DeleteInsightRulesError::InvalidParameterValue(parsed_error.message),
)
}
"MissingParameter" => {
return RusotoError::Service(
DeleteInsightRulesError::MissingRequiredParameter(parsed_error.message),
)
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DeleteInsightRulesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteInsightRulesError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
DeleteInsightRulesError::MissingRequiredParameter(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteInsightRulesError {}
#[derive(Debug, PartialEq)]
pub enum DescribeAlarmHistoryError {
InvalidNextToken(String),
}
impl DescribeAlarmHistoryError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeAlarmHistoryError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"InvalidNextToken" => {
return RusotoError::Service(DescribeAlarmHistoryError::InvalidNextToken(
parsed_error.message,
))
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeAlarmHistoryError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeAlarmHistoryError::InvalidNextToken(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeAlarmHistoryError {}
#[derive(Debug, PartialEq)]
pub enum DescribeAlarmsError {
InvalidNextToken(String),
}
impl DescribeAlarmsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeAlarmsError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"InvalidNextToken" => {
return RusotoError::Service(DescribeAlarmsError::InvalidNextToken(
parsed_error.message,
))
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeAlarmsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeAlarmsError::InvalidNextToken(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeAlarmsError {}
#[derive(Debug, PartialEq)]
pub enum DescribeAlarmsForMetricError {}
impl DescribeAlarmsForMetricError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeAlarmsForMetricError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeAlarmsForMetricError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {}
}
}
impl Error for DescribeAlarmsForMetricError {}
#[derive(Debug, PartialEq)]
pub enum DescribeAnomalyDetectorsError {
InternalServiceFault(String),
InvalidNextToken(String),
InvalidParameterValue(String),
}
impl DescribeAnomalyDetectorsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeAnomalyDetectorsError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"InternalServiceError" => {
return RusotoError::Service(
DescribeAnomalyDetectorsError::InternalServiceFault(
parsed_error.message,
),
)
}
"InvalidNextToken" => {
return RusotoError::Service(
DescribeAnomalyDetectorsError::InvalidNextToken(parsed_error.message),
)
}
"InvalidParameterValue" => {
return RusotoError::Service(
DescribeAnomalyDetectorsError::InvalidParameterValue(
parsed_error.message,
),
)
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeAnomalyDetectorsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeAnomalyDetectorsError::InternalServiceFault(ref cause) => {
write!(f, "{}", cause)
}
DescribeAnomalyDetectorsError::InvalidNextToken(ref cause) => write!(f, "{}", cause),
DescribeAnomalyDetectorsError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DescribeAnomalyDetectorsError {}
#[derive(Debug, PartialEq)]
pub enum DescribeInsightRulesError {
InvalidNextToken(String),
}
impl DescribeInsightRulesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeInsightRulesError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"InvalidNextToken" => {
return RusotoError::Service(DescribeInsightRulesError::InvalidNextToken(
parsed_error.message,
))
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeInsightRulesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeInsightRulesError::InvalidNextToken(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeInsightRulesError {}
#[derive(Debug, PartialEq)]
pub enum DisableAlarmActionsError {}
impl DisableAlarmActionsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DisableAlarmActionsError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DisableAlarmActionsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {}
}
}
impl Error for DisableAlarmActionsError {}
#[derive(Debug, PartialEq)]
pub enum DisableInsightRulesError {
InvalidParameterValue(String),
MissingRequiredParameter(String),
}
impl DisableInsightRulesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DisableInsightRulesError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"InvalidParameterValue" => {
return RusotoError::Service(
DisableInsightRulesError::InvalidParameterValue(parsed_error.message),
)
}
"MissingParameter" => {
return RusotoError::Service(
DisableInsightRulesError::MissingRequiredParameter(
parsed_error.message,
),
)
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DisableInsightRulesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DisableInsightRulesError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
DisableInsightRulesError::MissingRequiredParameter(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DisableInsightRulesError {}
#[derive(Debug, PartialEq)]
pub enum EnableAlarmActionsError {}
impl EnableAlarmActionsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<EnableAlarmActionsError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for EnableAlarmActionsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {}
}
}
impl Error for EnableAlarmActionsError {}
#[derive(Debug, PartialEq)]
pub enum EnableInsightRulesError {
InvalidParameterValue(String),
LimitExceeded(String),
MissingRequiredParameter(String),
}
impl EnableInsightRulesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<EnableInsightRulesError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"InvalidParameterValue" => {
return RusotoError::Service(
EnableInsightRulesError::InvalidParameterValue(parsed_error.message),
)
}
"LimitExceededException" => {
return RusotoError::Service(EnableInsightRulesError::LimitExceeded(
parsed_error.message,
))
}
"MissingParameter" => {
return RusotoError::Service(
EnableInsightRulesError::MissingRequiredParameter(parsed_error.message),
)
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for EnableInsightRulesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
EnableInsightRulesError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
EnableInsightRulesError::LimitExceeded(ref cause) => write!(f, "{}", cause),
EnableInsightRulesError::MissingRequiredParameter(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for EnableInsightRulesError {}
#[derive(Debug, PartialEq)]
pub enum GetDashboardError {
DashboardNotFoundError(String),
InternalServiceFault(String),
InvalidParameterValue(String),
}
impl GetDashboardError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetDashboardError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"ResourceNotFound" => {
return RusotoError::Service(GetDashboardError::DashboardNotFoundError(
parsed_error.message,
))
}
"InternalServiceError" => {
return RusotoError::Service(GetDashboardError::InternalServiceFault(
parsed_error.message,
))
}
"InvalidParameterValue" => {
return RusotoError::Service(GetDashboardError::InvalidParameterValue(
parsed_error.message,
))
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for GetDashboardError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetDashboardError::DashboardNotFoundError(ref cause) => write!(f, "{}", cause),
GetDashboardError::InternalServiceFault(ref cause) => write!(f, "{}", cause),
GetDashboardError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetDashboardError {}
#[derive(Debug, PartialEq)]
pub enum GetInsightRuleReportError {
InvalidParameterValue(String),
MissingRequiredParameter(String),
ResourceNotFound(String),
}
impl GetInsightRuleReportError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetInsightRuleReportError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"InvalidParameterValue" => {
return RusotoError::Service(
GetInsightRuleReportError::InvalidParameterValue(parsed_error.message),
)
}
"MissingParameter" => {
return RusotoError::Service(
GetInsightRuleReportError::MissingRequiredParameter(
parsed_error.message,
),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(GetInsightRuleReportError::ResourceNotFound(
parsed_error.message,
))
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for GetInsightRuleReportError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetInsightRuleReportError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
GetInsightRuleReportError::MissingRequiredParameter(ref cause) => {
write!(f, "{}", cause)
}
GetInsightRuleReportError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetInsightRuleReportError {}
#[derive(Debug, PartialEq)]
pub enum GetMetricDataError {
InvalidNextToken(String),
}
impl GetMetricDataError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetMetricDataError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"InvalidNextToken" => {
return RusotoError::Service(GetMetricDataError::InvalidNextToken(
parsed_error.message,
))
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for GetMetricDataError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetMetricDataError::InvalidNextToken(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetMetricDataError {}
#[derive(Debug, PartialEq)]
pub enum GetMetricStatisticsError {
InternalServiceFault(String),
InvalidParameterCombination(String),
InvalidParameterValue(String),
MissingRequiredParameter(String),
}
impl GetMetricStatisticsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetMetricStatisticsError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"InternalServiceError" => {
return RusotoError::Service(
GetMetricStatisticsError::InternalServiceFault(parsed_error.message),
)
}
"InvalidParameterCombination" => {
return RusotoError::Service(
GetMetricStatisticsError::InvalidParameterCombination(
parsed_error.message,
),
)
}
"InvalidParameterValue" => {
return RusotoError::Service(
GetMetricStatisticsError::InvalidParameterValue(parsed_error.message),
)
}
"MissingParameter" => {
return RusotoError::Service(
GetMetricStatisticsError::MissingRequiredParameter(
parsed_error.message,
),
)
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for GetMetricStatisticsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetMetricStatisticsError::InternalServiceFault(ref cause) => write!(f, "{}", cause),
GetMetricStatisticsError::InvalidParameterCombination(ref cause) => {
write!(f, "{}", cause)
}
GetMetricStatisticsError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
GetMetricStatisticsError::MissingRequiredParameter(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetMetricStatisticsError {}
#[derive(Debug, PartialEq)]
pub enum GetMetricWidgetImageError {}
impl GetMetricWidgetImageError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetMetricWidgetImageError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for GetMetricWidgetImageError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {}
}
}
impl Error for GetMetricWidgetImageError {}
#[derive(Debug, PartialEq)]
pub enum ListDashboardsError {
InternalServiceFault(String),
InvalidParameterValue(String),
}
impl ListDashboardsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListDashboardsError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"InternalServiceError" => {
return RusotoError::Service(ListDashboardsError::InternalServiceFault(
parsed_error.message,
))
}
"InvalidParameterValue" => {
return RusotoError::Service(ListDashboardsError::InvalidParameterValue(
parsed_error.message,
))
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for ListDashboardsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListDashboardsError::InternalServiceFault(ref cause) => write!(f, "{}", cause),
ListDashboardsError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListDashboardsError {}
#[derive(Debug, PartialEq)]
pub enum ListMetricsError {
InternalServiceFault(String),
InvalidParameterValue(String),
}
impl ListMetricsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListMetricsError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"InternalServiceError" => {
return RusotoError::Service(ListMetricsError::InternalServiceFault(
parsed_error.message,
))
}
"InvalidParameterValue" => {
return RusotoError::Service(ListMetricsError::InvalidParameterValue(
parsed_error.message,
))
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for ListMetricsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListMetricsError::InternalServiceFault(ref cause) => write!(f, "{}", cause),
ListMetricsError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListMetricsError {}
#[derive(Debug, PartialEq)]
pub enum ListTagsForResourceError {
InternalServiceFault(String),
InvalidParameterValue(String),
ResourceNotFound(String),
}
impl ListTagsForResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListTagsForResourceError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"InternalServiceError" => {
return RusotoError::Service(
ListTagsForResourceError::InternalServiceFault(parsed_error.message),
)
}
"InvalidParameterValue" => {
return RusotoError::Service(
ListTagsForResourceError::InvalidParameterValue(parsed_error.message),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(ListTagsForResourceError::ResourceNotFound(
parsed_error.message,
))
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for ListTagsForResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListTagsForResourceError::InternalServiceFault(ref cause) => write!(f, "{}", cause),
ListTagsForResourceError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
ListTagsForResourceError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListTagsForResourceError {}
#[derive(Debug, PartialEq)]
pub enum PutAnomalyDetectorError {
InternalServiceFault(String),
InvalidParameterValue(String),
LimitExceeded(String),
MissingRequiredParameter(String),
}
impl PutAnomalyDetectorError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<PutAnomalyDetectorError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"InternalServiceError" => {
return RusotoError::Service(PutAnomalyDetectorError::InternalServiceFault(
parsed_error.message,
))
}
"InvalidParameterValue" => {
return RusotoError::Service(
PutAnomalyDetectorError::InvalidParameterValue(parsed_error.message),
)
}
"LimitExceededException" => {
return RusotoError::Service(PutAnomalyDetectorError::LimitExceeded(
parsed_error.message,
))
}
"MissingParameter" => {
return RusotoError::Service(
PutAnomalyDetectorError::MissingRequiredParameter(parsed_error.message),
)
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for PutAnomalyDetectorError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
PutAnomalyDetectorError::InternalServiceFault(ref cause) => write!(f, "{}", cause),
PutAnomalyDetectorError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
PutAnomalyDetectorError::LimitExceeded(ref cause) => write!(f, "{}", cause),
PutAnomalyDetectorError::MissingRequiredParameter(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for PutAnomalyDetectorError {}
#[derive(Debug, PartialEq)]
pub enum PutCompositeAlarmError {
LimitExceededFault(String),
}
impl PutCompositeAlarmError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<PutCompositeAlarmError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"LimitExceeded" => {
return RusotoError::Service(PutCompositeAlarmError::LimitExceededFault(
parsed_error.message,
))
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for PutCompositeAlarmError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
PutCompositeAlarmError::LimitExceededFault(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for PutCompositeAlarmError {}
#[derive(Debug, PartialEq)]
pub enum PutDashboardError {
DashboardInvalidInputError(String),
InternalServiceFault(String),
}
impl PutDashboardError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<PutDashboardError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"InvalidParameterInput" => {
return RusotoError::Service(PutDashboardError::DashboardInvalidInputError(
parsed_error.message,
))
}
"InternalServiceError" => {
return RusotoError::Service(PutDashboardError::InternalServiceFault(
parsed_error.message,
))
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for PutDashboardError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
PutDashboardError::DashboardInvalidInputError(ref cause) => write!(f, "{}", cause),
PutDashboardError::InternalServiceFault(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for PutDashboardError {}
#[derive(Debug, PartialEq)]
pub enum PutInsightRuleError {
InvalidParameterValue(String),
LimitExceeded(String),
MissingRequiredParameter(String),
}
impl PutInsightRuleError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<PutInsightRuleError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"InvalidParameterValue" => {
return RusotoError::Service(PutInsightRuleError::InvalidParameterValue(
parsed_error.message,
))
}
"LimitExceededException" => {
return RusotoError::Service(PutInsightRuleError::LimitExceeded(
parsed_error.message,
))
}
"MissingParameter" => {
return RusotoError::Service(PutInsightRuleError::MissingRequiredParameter(
parsed_error.message,
))
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for PutInsightRuleError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
PutInsightRuleError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
PutInsightRuleError::LimitExceeded(ref cause) => write!(f, "{}", cause),
PutInsightRuleError::MissingRequiredParameter(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for PutInsightRuleError {}
#[derive(Debug, PartialEq)]
pub enum PutMetricAlarmError {
LimitExceededFault(String),
}
impl PutMetricAlarmError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<PutMetricAlarmError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"LimitExceeded" => {
return RusotoError::Service(PutMetricAlarmError::LimitExceededFault(
parsed_error.message,
))
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for PutMetricAlarmError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
PutMetricAlarmError::LimitExceededFault(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for PutMetricAlarmError {}
#[derive(Debug, PartialEq)]
pub enum PutMetricDataError {
InternalServiceFault(String),
InvalidParameterCombination(String),
InvalidParameterValue(String),
MissingRequiredParameter(String),
}
impl PutMetricDataError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<PutMetricDataError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"InternalServiceError" => {
return RusotoError::Service(PutMetricDataError::InternalServiceFault(
parsed_error.message,
))
}
"InvalidParameterCombination" => {
return RusotoError::Service(
PutMetricDataError::InvalidParameterCombination(parsed_error.message),
)
}
"InvalidParameterValue" => {
return RusotoError::Service(PutMetricDataError::InvalidParameterValue(
parsed_error.message,
))
}
"MissingParameter" => {
return RusotoError::Service(PutMetricDataError::MissingRequiredParameter(
parsed_error.message,
))
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for PutMetricDataError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
PutMetricDataError::InternalServiceFault(ref cause) => write!(f, "{}", cause),
PutMetricDataError::InvalidParameterCombination(ref cause) => write!(f, "{}", cause),
PutMetricDataError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
PutMetricDataError::MissingRequiredParameter(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for PutMetricDataError {}
#[derive(Debug, PartialEq)]
pub enum SetAlarmStateError {
InvalidFormatFault(String),
ResourceNotFound(String),
}
impl SetAlarmStateError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<SetAlarmStateError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"InvalidFormat" => {
return RusotoError::Service(SetAlarmStateError::InvalidFormatFault(
parsed_error.message,
))
}
"ResourceNotFound" => {
return RusotoError::Service(SetAlarmStateError::ResourceNotFound(
parsed_error.message,
))
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for SetAlarmStateError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
SetAlarmStateError::InvalidFormatFault(ref cause) => write!(f, "{}", cause),
SetAlarmStateError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for SetAlarmStateError {}
#[derive(Debug, PartialEq)]
pub enum TagResourceError {
ConcurrentModification(String),
InternalServiceFault(String),
InvalidParameterValue(String),
ResourceNotFound(String),
}
impl TagResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<TagResourceError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"ConcurrentModificationException" => {
return RusotoError::Service(TagResourceError::ConcurrentModification(
parsed_error.message,
))
}
"InternalServiceError" => {
return RusotoError::Service(TagResourceError::InternalServiceFault(
parsed_error.message,
))
}
"InvalidParameterValue" => {
return RusotoError::Service(TagResourceError::InvalidParameterValue(
parsed_error.message,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(TagResourceError::ResourceNotFound(
parsed_error.message,
))
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for TagResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
TagResourceError::ConcurrentModification(ref cause) => write!(f, "{}", cause),
TagResourceError::InternalServiceFault(ref cause) => write!(f, "{}", cause),
TagResourceError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
TagResourceError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for TagResourceError {}
#[derive(Debug, PartialEq)]
pub enum UntagResourceError {
ConcurrentModification(String),
InternalServiceFault(String),
InvalidParameterValue(String),
ResourceNotFound(String),
}
impl UntagResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UntagResourceError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"ConcurrentModificationException" => {
return RusotoError::Service(UntagResourceError::ConcurrentModification(
parsed_error.message,
))
}
"InternalServiceError" => {
return RusotoError::Service(UntagResourceError::InternalServiceFault(
parsed_error.message,
))
}
"InvalidParameterValue" => {
return RusotoError::Service(UntagResourceError::InvalidParameterValue(
parsed_error.message,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(UntagResourceError::ResourceNotFound(
parsed_error.message,
))
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for UntagResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UntagResourceError::ConcurrentModification(ref cause) => write!(f, "{}", cause),
UntagResourceError::InternalServiceFault(ref cause) => write!(f, "{}", cause),
UntagResourceError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
UntagResourceError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UntagResourceError {}
#[async_trait]
pub trait CloudWatch {
async fn delete_alarms(
&self,
input: DeleteAlarmsInput,
) -> Result<(), RusotoError<DeleteAlarmsError>>;
async fn delete_anomaly_detector(
&self,
input: DeleteAnomalyDetectorInput,
) -> Result<DeleteAnomalyDetectorOutput, RusotoError<DeleteAnomalyDetectorError>>;
async fn delete_dashboards(
&self,
input: DeleteDashboardsInput,
) -> Result<DeleteDashboardsOutput, RusotoError<DeleteDashboardsError>>;
async fn delete_insight_rules(
&self,
input: DeleteInsightRulesInput,
) -> Result<DeleteInsightRulesOutput, RusotoError<DeleteInsightRulesError>>;
async fn describe_alarm_history(
&self,
input: DescribeAlarmHistoryInput,
) -> Result<DescribeAlarmHistoryOutput, RusotoError<DescribeAlarmHistoryError>>;
async fn describe_alarms(
&self,
input: DescribeAlarmsInput,
) -> Result<DescribeAlarmsOutput, RusotoError<DescribeAlarmsError>>;
async fn describe_alarms_for_metric(
&self,
input: DescribeAlarmsForMetricInput,
) -> Result<DescribeAlarmsForMetricOutput, RusotoError<DescribeAlarmsForMetricError>>;
async fn describe_anomaly_detectors(
&self,
input: DescribeAnomalyDetectorsInput,
) -> Result<DescribeAnomalyDetectorsOutput, RusotoError<DescribeAnomalyDetectorsError>>;
async fn describe_insight_rules(
&self,
input: DescribeInsightRulesInput,
) -> Result<DescribeInsightRulesOutput, RusotoError<DescribeInsightRulesError>>;
async fn disable_alarm_actions(
&self,
input: DisableAlarmActionsInput,
) -> Result<(), RusotoError<DisableAlarmActionsError>>;
async fn disable_insight_rules(
&self,
input: DisableInsightRulesInput,
) -> Result<DisableInsightRulesOutput, RusotoError<DisableInsightRulesError>>;
async fn enable_alarm_actions(
&self,
input: EnableAlarmActionsInput,
) -> Result<(), RusotoError<EnableAlarmActionsError>>;
async fn enable_insight_rules(
&self,
input: EnableInsightRulesInput,
) -> Result<EnableInsightRulesOutput, RusotoError<EnableInsightRulesError>>;
async fn get_dashboard(
&self,
input: GetDashboardInput,
) -> Result<GetDashboardOutput, RusotoError<GetDashboardError>>;
async fn get_insight_rule_report(
&self,
input: GetInsightRuleReportInput,
) -> Result<GetInsightRuleReportOutput, RusotoError<GetInsightRuleReportError>>;
async fn get_metric_data(
&self,
input: GetMetricDataInput,
) -> Result<GetMetricDataOutput, RusotoError<GetMetricDataError>>;
async fn get_metric_statistics(
&self,
input: GetMetricStatisticsInput,
) -> Result<GetMetricStatisticsOutput, RusotoError<GetMetricStatisticsError>>;
async fn get_metric_widget_image(
&self,
input: GetMetricWidgetImageInput,
) -> Result<GetMetricWidgetImageOutput, RusotoError<GetMetricWidgetImageError>>;
async fn list_dashboards(
&self,
input: ListDashboardsInput,
) -> Result<ListDashboardsOutput, RusotoError<ListDashboardsError>>;
async fn list_metrics(
&self,
input: ListMetricsInput,
) -> Result<ListMetricsOutput, RusotoError<ListMetricsError>>;
async fn list_tags_for_resource(
&self,
input: ListTagsForResourceInput,
) -> Result<ListTagsForResourceOutput, RusotoError<ListTagsForResourceError>>;
async fn put_anomaly_detector(
&self,
input: PutAnomalyDetectorInput,
) -> Result<PutAnomalyDetectorOutput, RusotoError<PutAnomalyDetectorError>>;
async fn put_composite_alarm(
&self,
input: PutCompositeAlarmInput,
) -> Result<(), RusotoError<PutCompositeAlarmError>>;
async fn put_dashboard(
&self,
input: PutDashboardInput,
) -> Result<PutDashboardOutput, RusotoError<PutDashboardError>>;
async fn put_insight_rule(
&self,
input: PutInsightRuleInput,
) -> Result<PutInsightRuleOutput, RusotoError<PutInsightRuleError>>;
async fn put_metric_alarm(
&self,
input: PutMetricAlarmInput,
) -> Result<(), RusotoError<PutMetricAlarmError>>;
async fn put_metric_data(
&self,
input: PutMetricDataInput,
) -> Result<(), RusotoError<PutMetricDataError>>;
async fn set_alarm_state(
&self,
input: SetAlarmStateInput,
) -> Result<(), RusotoError<SetAlarmStateError>>;
async fn tag_resource(
&self,
input: TagResourceInput,
) -> Result<TagResourceOutput, RusotoError<TagResourceError>>;
async fn untag_resource(
&self,
input: UntagResourceInput,
) -> Result<UntagResourceOutput, RusotoError<UntagResourceError>>;
}
#[derive(Clone)]
pub struct CloudWatchClient {
client: Client,
region: region::Region,
}
impl CloudWatchClient {
pub fn new(region: region::Region) -> CloudWatchClient {
CloudWatchClient {
client: Client::shared(),
region,
}
}
pub fn new_with<P, D>(
request_dispatcher: D,
credentials_provider: P,
region: region::Region,
) -> CloudWatchClient
where
P: ProvideAwsCredentials + Send + Sync + 'static,
D: DispatchSignedRequest + Send + Sync + 'static,
{
CloudWatchClient {
client: Client::new_with(credentials_provider, request_dispatcher),
region,
}
}
pub fn new_with_client(client: Client, region: region::Region) -> CloudWatchClient {
CloudWatchClient { client, region }
}
}
#[async_trait]
impl CloudWatch for CloudWatchClient {
async fn delete_alarms(
&self,
input: DeleteAlarmsInput,
) -> Result<(), RusotoError<DeleteAlarmsError>> {
let mut request = SignedRequest::new("POST", "monitoring", &self.region, "/");
let params = self.new_params("DeleteAlarms");
let mut params = params;
DeleteAlarmsInputSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, DeleteAlarmsError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
async fn delete_anomaly_detector(
&self,
input: DeleteAnomalyDetectorInput,
) -> Result<DeleteAnomalyDetectorOutput, RusotoError<DeleteAnomalyDetectorError>> {
let mut request = SignedRequest::new("POST", "monitoring", &self.region, "/");
let params = self.new_params("DeleteAnomalyDetector");
let mut params = params;
DeleteAnomalyDetectorInputSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, DeleteAnomalyDetectorError::from_response)
.await?;
let result = DeleteAnomalyDetectorOutput::default();
drop(response);
Ok(result)
}
async fn delete_dashboards(
&self,
input: DeleteDashboardsInput,
) -> Result<DeleteDashboardsOutput, RusotoError<DeleteDashboardsError>> {
let mut request = SignedRequest::new("POST", "monitoring", &self.region, "/");
let params = self.new_params("DeleteDashboards");
let mut params = params;
DeleteDashboardsInputSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, DeleteDashboardsError::from_response)
.await?;
let result = DeleteDashboardsOutput::default();
drop(response);
Ok(result)
}
async fn delete_insight_rules(
&self,
input: DeleteInsightRulesInput,
) -> Result<DeleteInsightRulesOutput, RusotoError<DeleteInsightRulesError>> {
let mut request = SignedRequest::new("POST", "monitoring", &self.region, "/");
let params = self.new_params("DeleteInsightRules");
let mut params = params;
DeleteInsightRulesInputSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, DeleteInsightRulesError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result = DeleteInsightRulesOutputDeserializer::deserialize(
"DeleteInsightRulesResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn describe_alarm_history(
&self,
input: DescribeAlarmHistoryInput,
) -> Result<DescribeAlarmHistoryOutput, RusotoError<DescribeAlarmHistoryError>> {
let mut request = SignedRequest::new("POST", "monitoring", &self.region, "/");
let params = self.new_params("DescribeAlarmHistory");
let mut params = params;
DescribeAlarmHistoryInputSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, DescribeAlarmHistoryError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result = DescribeAlarmHistoryOutputDeserializer::deserialize(
"DescribeAlarmHistoryResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn describe_alarms(
&self,
input: DescribeAlarmsInput,
) -> Result<DescribeAlarmsOutput, RusotoError<DescribeAlarmsError>> {
let mut request = SignedRequest::new("POST", "monitoring", &self.region, "/");
let params = self.new_params("DescribeAlarms");
let mut params = params;
DescribeAlarmsInputSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, DescribeAlarmsError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result =
DescribeAlarmsOutputDeserializer::deserialize("DescribeAlarmsResult", stack)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn describe_alarms_for_metric(
&self,
input: DescribeAlarmsForMetricInput,
) -> Result<DescribeAlarmsForMetricOutput, RusotoError<DescribeAlarmsForMetricError>> {
let mut request = SignedRequest::new("POST", "monitoring", &self.region, "/");
let params = self.new_params("DescribeAlarmsForMetric");
let mut params = params;
DescribeAlarmsForMetricInputSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, DescribeAlarmsForMetricError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result = DescribeAlarmsForMetricOutputDeserializer::deserialize(
"DescribeAlarmsForMetricResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn describe_anomaly_detectors(
&self,
input: DescribeAnomalyDetectorsInput,
) -> Result<DescribeAnomalyDetectorsOutput, RusotoError<DescribeAnomalyDetectorsError>> {
let mut request = SignedRequest::new("POST", "monitoring", &self.region, "/");
let params = self.new_params("DescribeAnomalyDetectors");
let mut params = params;
DescribeAnomalyDetectorsInputSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, DescribeAnomalyDetectorsError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result = DescribeAnomalyDetectorsOutputDeserializer::deserialize(
"DescribeAnomalyDetectorsResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn describe_insight_rules(
&self,
input: DescribeInsightRulesInput,
) -> Result<DescribeInsightRulesOutput, RusotoError<DescribeInsightRulesError>> {
let mut request = SignedRequest::new("POST", "monitoring", &self.region, "/");
let params = self.new_params("DescribeInsightRules");
let mut params = params;
DescribeInsightRulesInputSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, DescribeInsightRulesError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result = DescribeInsightRulesOutputDeserializer::deserialize(
"DescribeInsightRulesResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn disable_alarm_actions(
&self,
input: DisableAlarmActionsInput,
) -> Result<(), RusotoError<DisableAlarmActionsError>> {
let mut request = SignedRequest::new("POST", "monitoring", &self.region, "/");
let params = self.new_params("DisableAlarmActions");
let mut params = params;
DisableAlarmActionsInputSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, DisableAlarmActionsError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
async fn disable_insight_rules(
&self,
input: DisableInsightRulesInput,
) -> Result<DisableInsightRulesOutput, RusotoError<DisableInsightRulesError>> {
let mut request = SignedRequest::new("POST", "monitoring", &self.region, "/");
let params = self.new_params("DisableInsightRules");
let mut params = params;
DisableInsightRulesInputSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, DisableInsightRulesError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result = DisableInsightRulesOutputDeserializer::deserialize(
"DisableInsightRulesResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn enable_alarm_actions(
&self,
input: EnableAlarmActionsInput,
) -> Result<(), RusotoError<EnableAlarmActionsError>> {
let mut request = SignedRequest::new("POST", "monitoring", &self.region, "/");
let params = self.new_params("EnableAlarmActions");
let mut params = params;
EnableAlarmActionsInputSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, EnableAlarmActionsError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
async fn enable_insight_rules(
&self,
input: EnableInsightRulesInput,
) -> Result<EnableInsightRulesOutput, RusotoError<EnableInsightRulesError>> {
let mut request = SignedRequest::new("POST", "monitoring", &self.region, "/");
let params = self.new_params("EnableInsightRules");
let mut params = params;
EnableInsightRulesInputSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, EnableInsightRulesError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result = EnableInsightRulesOutputDeserializer::deserialize(
"EnableInsightRulesResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn get_dashboard(
&self,
input: GetDashboardInput,
) -> Result<GetDashboardOutput, RusotoError<GetDashboardError>> {
let mut request = SignedRequest::new("POST", "monitoring", &self.region, "/");
let params = self.new_params("GetDashboard");
let mut params = params;
GetDashboardInputSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, GetDashboardError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result = GetDashboardOutputDeserializer::deserialize("GetDashboardResult", stack)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn get_insight_rule_report(
&self,
input: GetInsightRuleReportInput,
) -> Result<GetInsightRuleReportOutput, RusotoError<GetInsightRuleReportError>> {
let mut request = SignedRequest::new("POST", "monitoring", &self.region, "/");
let params = self.new_params("GetInsightRuleReport");
let mut params = params;
GetInsightRuleReportInputSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, GetInsightRuleReportError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result = GetInsightRuleReportOutputDeserializer::deserialize(
"GetInsightRuleReportResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn get_metric_data(
&self,
input: GetMetricDataInput,
) -> Result<GetMetricDataOutput, RusotoError<GetMetricDataError>> {
let mut request = SignedRequest::new("POST", "monitoring", &self.region, "/");
let params = self.new_params("GetMetricData");
let mut params = params;
GetMetricDataInputSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, GetMetricDataError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result =
GetMetricDataOutputDeserializer::deserialize("GetMetricDataResult", stack)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn get_metric_statistics(
&self,
input: GetMetricStatisticsInput,
) -> Result<GetMetricStatisticsOutput, RusotoError<GetMetricStatisticsError>> {
let mut request = SignedRequest::new("POST", "monitoring", &self.region, "/");
let params = self.new_params("GetMetricStatistics");
let mut params = params;
GetMetricStatisticsInputSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, GetMetricStatisticsError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result = GetMetricStatisticsOutputDeserializer::deserialize(
"GetMetricStatisticsResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn get_metric_widget_image(
&self,
input: GetMetricWidgetImageInput,
) -> Result<GetMetricWidgetImageOutput, RusotoError<GetMetricWidgetImageError>> {
let mut request = SignedRequest::new("POST", "monitoring", &self.region, "/");
let params = self.new_params("GetMetricWidgetImage");
let mut params = params;
GetMetricWidgetImageInputSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, GetMetricWidgetImageError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result = GetMetricWidgetImageOutputDeserializer::deserialize(
"GetMetricWidgetImageResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn list_dashboards(
&self,
input: ListDashboardsInput,
) -> Result<ListDashboardsOutput, RusotoError<ListDashboardsError>> {
let mut request = SignedRequest::new("POST", "monitoring", &self.region, "/");
let params = self.new_params("ListDashboards");
let mut params = params;
ListDashboardsInputSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, ListDashboardsError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result =
ListDashboardsOutputDeserializer::deserialize("ListDashboardsResult", stack)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn list_metrics(
&self,
input: ListMetricsInput,
) -> Result<ListMetricsOutput, RusotoError<ListMetricsError>> {
let mut request = SignedRequest::new("POST", "monitoring", &self.region, "/");
let params = self.new_params("ListMetrics");
let mut params = params;
ListMetricsInputSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, ListMetricsError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result = ListMetricsOutputDeserializer::deserialize("ListMetricsResult", stack)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn list_tags_for_resource(
&self,
input: ListTagsForResourceInput,
) -> Result<ListTagsForResourceOutput, RusotoError<ListTagsForResourceError>> {
let mut request = SignedRequest::new("POST", "monitoring", &self.region, "/");
let params = self.new_params("ListTagsForResource");
let mut params = params;
ListTagsForResourceInputSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, ListTagsForResourceError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result = ListTagsForResourceOutputDeserializer::deserialize(
"ListTagsForResourceResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn put_anomaly_detector(
&self,
input: PutAnomalyDetectorInput,
) -> Result<PutAnomalyDetectorOutput, RusotoError<PutAnomalyDetectorError>> {
let mut request = SignedRequest::new("POST", "monitoring", &self.region, "/");
let params = self.new_params("PutAnomalyDetector");
let mut params = params;
PutAnomalyDetectorInputSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, PutAnomalyDetectorError::from_response)
.await?;
let result = PutAnomalyDetectorOutput::default();
drop(response);
Ok(result)
}
async fn put_composite_alarm(
&self,
input: PutCompositeAlarmInput,
) -> Result<(), RusotoError<PutCompositeAlarmError>> {
let mut request = SignedRequest::new("POST", "monitoring", &self.region, "/");
let params = self.new_params("PutCompositeAlarm");
let mut params = params;
PutCompositeAlarmInputSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, PutCompositeAlarmError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
async fn put_dashboard(
&self,
input: PutDashboardInput,
) -> Result<PutDashboardOutput, RusotoError<PutDashboardError>> {
let mut request = SignedRequest::new("POST", "monitoring", &self.region, "/");
let params = self.new_params("PutDashboard");
let mut params = params;
PutDashboardInputSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, PutDashboardError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result = PutDashboardOutputDeserializer::deserialize("PutDashboardResult", stack)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn put_insight_rule(
&self,
input: PutInsightRuleInput,
) -> Result<PutInsightRuleOutput, RusotoError<PutInsightRuleError>> {
let mut request = SignedRequest::new("POST", "monitoring", &self.region, "/");
let params = self.new_params("PutInsightRule");
let mut params = params;
PutInsightRuleInputSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, PutInsightRuleError::from_response)
.await?;
let result = PutInsightRuleOutput::default();
drop(response);
Ok(result)
}
async fn put_metric_alarm(
&self,
input: PutMetricAlarmInput,
) -> Result<(), RusotoError<PutMetricAlarmError>> {
let mut request = SignedRequest::new("POST", "monitoring", &self.region, "/");
let params = self.new_params("PutMetricAlarm");
let mut params = params;
PutMetricAlarmInputSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, PutMetricAlarmError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
async fn put_metric_data(
&self,
input: PutMetricDataInput,
) -> Result<(), RusotoError<PutMetricDataError>> {
let mut request = SignedRequest::new("POST", "monitoring", &self.region, "/");
let params = self.new_params("PutMetricData");
let mut params = params;
PutMetricDataInputSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, PutMetricDataError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
async fn set_alarm_state(
&self,
input: SetAlarmStateInput,
) -> Result<(), RusotoError<SetAlarmStateError>> {
let mut request = SignedRequest::new("POST", "monitoring", &self.region, "/");
let params = self.new_params("SetAlarmState");
let mut params = params;
SetAlarmStateInputSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, SetAlarmStateError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
async fn tag_resource(
&self,
input: TagResourceInput,
) -> Result<TagResourceOutput, RusotoError<TagResourceError>> {
let mut request = SignedRequest::new("POST", "monitoring", &self.region, "/");
let params = self.new_params("TagResource");
let mut params = params;
TagResourceInputSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, TagResourceError::from_response)
.await?;
let result = TagResourceOutput::default();
drop(response);
Ok(result)
}
async fn untag_resource(
&self,
input: UntagResourceInput,
) -> Result<UntagResourceOutput, RusotoError<UntagResourceError>> {
let mut request = SignedRequest::new("POST", "monitoring", &self.region, "/");
let params = self.new_params("UntagResource");
let mut params = params;
UntagResourceInputSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, UntagResourceError::from_response)
.await?;
let result = UntagResourceOutput::default();
drop(response);
Ok(result)
}
}
#[cfg(test)]
mod protocol_tests {
extern crate rusoto_mock;
use self::rusoto_mock::*;
use super::*;
use rusoto_core::Region as rusoto_region;
#[tokio::test]
async 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).await;
assert!(!result.is_ok(), "parse error: {:?}", result);
}
#[tokio::test]
async 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).await;
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[tokio::test]
async 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).await;
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[tokio::test]
async 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).await;
assert!(result.is_ok(), "parse error: {:?}", result);
}
}