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 RedshiftClient {
fn new_params(&self, operation_name: &str) -> Params {
let mut params = Params::new();
params.put("Action", operation_name);
params.put("Version", "2012-12-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)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AcceptReservedNodeExchangeInputMessage {
pub reserved_node_id: String,
pub target_reserved_node_offering_id: String,
}
struct AcceptReservedNodeExchangeInputMessageSerializer;
impl AcceptReservedNodeExchangeInputMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &AcceptReservedNodeExchangeInputMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "ReservedNodeId"),
&obj.reserved_node_id,
);
params.put(
&format!("{}{}", prefix, "TargetReservedNodeOfferingId"),
&obj.target_reserved_node_offering_id,
);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct AcceptReservedNodeExchangeOutputMessage {
pub exchanged_reserved_node: Option<ReservedNode>,
}
#[allow(dead_code)]
struct AcceptReservedNodeExchangeOutputMessageDeserializer;
impl AcceptReservedNodeExchangeOutputMessageDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<AcceptReservedNodeExchangeOutputMessage, XmlParseError> {
deserialize_elements::<_, AcceptReservedNodeExchangeOutputMessage, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"ExchangedReservedNode" => {
obj.exchanged_reserved_node = Some(ReservedNodeDeserializer::deserialize(
"ExchangedReservedNode",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct AccountAttribute {
pub attribute_name: Option<String>,
pub attribute_values: Option<Vec<AttributeValueTarget>>,
}
#[allow(dead_code)]
struct AccountAttributeDeserializer;
impl AccountAttributeDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<AccountAttribute, XmlParseError> {
deserialize_elements::<_, AccountAttribute, _>(tag_name, stack, |name, stack, obj| {
match name {
"AttributeName" => {
obj.attribute_name =
Some(StringDeserializer::deserialize("AttributeName", stack)?);
}
"AttributeValues" => {
obj.attribute_values.get_or_insert(vec![]).extend(
AttributeValueListDeserializer::deserialize("AttributeValues", stack)?,
);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct AccountAttributeList {
pub account_attributes: Option<Vec<AccountAttribute>>,
}
#[allow(dead_code)]
struct AccountAttributeListDeserializer;
impl AccountAttributeListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<AccountAttributeList, XmlParseError> {
deserialize_elements::<_, AccountAttributeList, _>(tag_name, stack, |name, stack, obj| {
match name {
"AccountAttributes" => {
obj.account_attributes.get_or_insert(vec![]).extend(
AttributeListDeserializer::deserialize("AccountAttributes", stack)?,
);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct AccountWithRestoreAccess {
pub account_alias: Option<String>,
pub account_id: Option<String>,
}
#[allow(dead_code)]
struct AccountWithRestoreAccessDeserializer;
impl AccountWithRestoreAccessDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<AccountWithRestoreAccess, XmlParseError> {
deserialize_elements::<_, AccountWithRestoreAccess, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"AccountAlias" => {
obj.account_alias =
Some(StringDeserializer::deserialize("AccountAlias", stack)?);
}
"AccountId" => {
obj.account_id = Some(StringDeserializer::deserialize("AccountId", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[allow(dead_code)]
struct AccountsWithRestoreAccessListDeserializer;
impl AccountsWithRestoreAccessListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<AccountWithRestoreAccess>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "AccountWithRestoreAccess" {
obj.push(AccountWithRestoreAccessDeserializer::deserialize(
"AccountWithRestoreAccess",
stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[allow(dead_code)]
struct AssociatedClusterListDeserializer;
impl AssociatedClusterListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<ClusterAssociatedToSchedule>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "ClusterAssociatedToSchedule" {
obj.push(ClusterAssociatedToScheduleDeserializer::deserialize(
"ClusterAssociatedToSchedule",
stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[allow(dead_code)]
struct AttributeListDeserializer;
impl AttributeListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<AccountAttribute>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "AccountAttribute" {
obj.push(AccountAttributeDeserializer::deserialize(
"AccountAttribute",
stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct AttributeNameListSerializer;
impl AttributeNameListSerializer {
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 AttributeValueListDeserializer;
impl AttributeValueListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<AttributeValueTarget>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "AttributeValueTarget" {
obj.push(AttributeValueTargetDeserializer::deserialize(
"AttributeValueTarget",
stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct AttributeValueTarget {
pub attribute_value: Option<String>,
}
#[allow(dead_code)]
struct AttributeValueTargetDeserializer;
impl AttributeValueTargetDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<AttributeValueTarget, XmlParseError> {
deserialize_elements::<_, AttributeValueTarget, _>(tag_name, stack, |name, stack, obj| {
match name {
"AttributeValue" => {
obj.attribute_value =
Some(StringDeserializer::deserialize("AttributeValue", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AuthorizeClusterSecurityGroupIngressMessage {
pub cidrip: Option<String>,
pub cluster_security_group_name: String,
pub ec2_security_group_name: Option<String>,
pub ec2_security_group_owner_id: Option<String>,
}
struct AuthorizeClusterSecurityGroupIngressMessageSerializer;
impl AuthorizeClusterSecurityGroupIngressMessageSerializer {
fn serialize(
params: &mut Params,
name: &str,
obj: &AuthorizeClusterSecurityGroupIngressMessage,
) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.cidrip {
params.put(&format!("{}{}", prefix, "CIDRIP"), &field_value);
}
params.put(
&format!("{}{}", prefix, "ClusterSecurityGroupName"),
&obj.cluster_security_group_name,
);
if let Some(ref field_value) = obj.ec2_security_group_name {
params.put(
&format!("{}{}", prefix, "EC2SecurityGroupName"),
&field_value,
);
}
if let Some(ref field_value) = obj.ec2_security_group_owner_id {
params.put(
&format!("{}{}", prefix, "EC2SecurityGroupOwnerId"),
&field_value,
);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct AuthorizeClusterSecurityGroupIngressResult {
pub cluster_security_group: Option<ClusterSecurityGroup>,
}
#[allow(dead_code)]
struct AuthorizeClusterSecurityGroupIngressResultDeserializer;
impl AuthorizeClusterSecurityGroupIngressResultDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<AuthorizeClusterSecurityGroupIngressResult, XmlParseError> {
deserialize_elements::<_, AuthorizeClusterSecurityGroupIngressResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"ClusterSecurityGroup" => {
obj.cluster_security_group =
Some(ClusterSecurityGroupDeserializer::deserialize(
"ClusterSecurityGroup",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AuthorizeSnapshotAccessMessage {
pub account_with_restore_access: String,
pub snapshot_cluster_identifier: Option<String>,
pub snapshot_identifier: String,
}
struct AuthorizeSnapshotAccessMessageSerializer;
impl AuthorizeSnapshotAccessMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &AuthorizeSnapshotAccessMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "AccountWithRestoreAccess"),
&obj.account_with_restore_access,
);
if let Some(ref field_value) = obj.snapshot_cluster_identifier {
params.put(
&format!("{}{}", prefix, "SnapshotClusterIdentifier"),
&field_value,
);
}
params.put(
&format!("{}{}", prefix, "SnapshotIdentifier"),
&obj.snapshot_identifier,
);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct AuthorizeSnapshotAccessResult {
pub snapshot: Option<Snapshot>,
}
#[allow(dead_code)]
struct AuthorizeSnapshotAccessResultDeserializer;
impl AuthorizeSnapshotAccessResultDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<AuthorizeSnapshotAccessResult, XmlParseError> {
deserialize_elements::<_, AuthorizeSnapshotAccessResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"Snapshot" => {
obj.snapshot = Some(SnapshotDeserializer::deserialize("Snapshot", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct AvailabilityZone {
pub name: Option<String>,
pub supported_platforms: Option<Vec<SupportedPlatform>>,
}
#[allow(dead_code)]
struct AvailabilityZoneDeserializer;
impl AvailabilityZoneDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<AvailabilityZone, XmlParseError> {
deserialize_elements::<_, AvailabilityZone, _>(tag_name, stack, |name, stack, obj| {
match name {
"Name" => {
obj.name = Some(StringDeserializer::deserialize("Name", stack)?);
}
"SupportedPlatforms" => {
obj.supported_platforms.get_or_insert(vec![]).extend(
SupportedPlatformsListDeserializer::deserialize(
"SupportedPlatforms",
stack,
)?,
);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[allow(dead_code)]
struct AvailabilityZoneListDeserializer;
impl AvailabilityZoneListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<AvailabilityZone>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "AvailabilityZone" {
obj.push(AvailabilityZoneDeserializer::deserialize(
"AvailabilityZone",
stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct BatchDeleteClusterSnapshotsRequest {
pub identifiers: Vec<DeleteClusterSnapshotMessage>,
}
struct BatchDeleteClusterSnapshotsRequestSerializer;
impl BatchDeleteClusterSnapshotsRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &BatchDeleteClusterSnapshotsRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
DeleteClusterSnapshotMessageListSerializer::serialize(
params,
&format!("{}{}", prefix, "DeleteClusterSnapshotMessage"),
&obj.identifiers,
);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct BatchDeleteClusterSnapshotsResult {
pub errors: Option<Vec<SnapshotErrorMessage>>,
pub resources: Option<Vec<String>>,
}
#[allow(dead_code)]
struct BatchDeleteClusterSnapshotsResultDeserializer;
impl BatchDeleteClusterSnapshotsResultDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<BatchDeleteClusterSnapshotsResult, XmlParseError> {
deserialize_elements::<_, BatchDeleteClusterSnapshotsResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"Errors" => {
obj.errors.get_or_insert(vec![]).extend(
BatchSnapshotOperationErrorListDeserializer::deserialize(
"Errors", stack,
)?,
);
}
"Resources" => {
obj.resources.get_or_insert(vec![]).extend(
SnapshotIdentifierListDeserializer::deserialize("Resources", stack)?,
);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct BatchModifyClusterSnapshotsMessage {
pub force: Option<bool>,
pub manual_snapshot_retention_period: Option<i64>,
pub snapshot_identifier_list: Vec<String>,
}
struct BatchModifyClusterSnapshotsMessageSerializer;
impl BatchModifyClusterSnapshotsMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &BatchModifyClusterSnapshotsMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.force {
params.put(&format!("{}{}", prefix, "Force"), &field_value);
}
if let Some(ref field_value) = obj.manual_snapshot_retention_period {
params.put(
&format!("{}{}", prefix, "ManualSnapshotRetentionPeriod"),
&field_value,
);
}
SnapshotIdentifierListSerializer::serialize(
params,
&format!("{}{}", prefix, "String"),
&obj.snapshot_identifier_list,
);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct BatchModifyClusterSnapshotsOutputMessage {
pub errors: Option<Vec<SnapshotErrorMessage>>,
pub resources: Option<Vec<String>>,
}
#[allow(dead_code)]
struct BatchModifyClusterSnapshotsOutputMessageDeserializer;
impl BatchModifyClusterSnapshotsOutputMessageDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<BatchModifyClusterSnapshotsOutputMessage, XmlParseError> {
deserialize_elements::<_, BatchModifyClusterSnapshotsOutputMessage, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"Errors" => {
obj.errors.get_or_insert(vec![]).extend(
BatchSnapshotOperationErrorsDeserializer::deserialize("Errors", stack)?,
);
}
"Resources" => {
obj.resources.get_or_insert(vec![]).extend(
SnapshotIdentifierListDeserializer::deserialize("Resources", stack)?,
);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[allow(dead_code)]
struct BatchSnapshotOperationErrorListDeserializer;
impl BatchSnapshotOperationErrorListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<SnapshotErrorMessage>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "SnapshotErrorMessage" {
obj.push(SnapshotErrorMessageDeserializer::deserialize(
"SnapshotErrorMessage",
stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[allow(dead_code)]
struct BatchSnapshotOperationErrorsDeserializer;
impl BatchSnapshotOperationErrorsDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<SnapshotErrorMessage>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "SnapshotErrorMessage" {
obj.push(SnapshotErrorMessageDeserializer::deserialize(
"SnapshotErrorMessage",
stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[allow(dead_code)]
struct BooleanDeserializer;
impl BooleanDeserializer {
#[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 BooleanOptionalDeserializer;
impl BooleanOptionalDeserializer {
#[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 CancelResizeMessage {
pub cluster_identifier: String,
}
struct CancelResizeMessageSerializer;
impl CancelResizeMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CancelResizeMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "ClusterIdentifier"),
&obj.cluster_identifier,
);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct Cluster {
pub allow_version_upgrade: Option<bool>,
pub automated_snapshot_retention_period: Option<i64>,
pub availability_zone: Option<String>,
pub cluster_availability_status: Option<String>,
pub cluster_create_time: Option<String>,
pub cluster_identifier: Option<String>,
pub cluster_nodes: Option<Vec<ClusterNode>>,
pub cluster_parameter_groups: Option<Vec<ClusterParameterGroupStatus>>,
pub cluster_public_key: Option<String>,
pub cluster_revision_number: Option<String>,
pub cluster_security_groups: Option<Vec<ClusterSecurityGroupMembership>>,
pub cluster_snapshot_copy_status: Option<ClusterSnapshotCopyStatus>,
pub cluster_status: Option<String>,
pub cluster_subnet_group_name: Option<String>,
pub cluster_version: Option<String>,
pub db_name: Option<String>,
pub data_transfer_progress: Option<DataTransferProgress>,
pub deferred_maintenance_windows: Option<Vec<DeferredMaintenanceWindow>>,
pub elastic_ip_status: Option<ElasticIpStatus>,
pub elastic_resize_number_of_node_options: Option<String>,
pub encrypted: Option<bool>,
pub endpoint: Option<Endpoint>,
pub enhanced_vpc_routing: Option<bool>,
pub expected_next_snapshot_schedule_time: Option<String>,
pub expected_next_snapshot_schedule_time_status: Option<String>,
pub hsm_status: Option<HsmStatus>,
pub iam_roles: Option<Vec<ClusterIamRole>>,
pub kms_key_id: Option<String>,
pub maintenance_track_name: Option<String>,
pub manual_snapshot_retention_period: Option<i64>,
pub master_username: Option<String>,
pub modify_status: Option<String>,
pub next_maintenance_window_start_time: Option<String>,
pub node_type: Option<String>,
pub number_of_nodes: Option<i64>,
pub pending_actions: Option<Vec<String>>,
pub pending_modified_values: Option<PendingModifiedValues>,
pub preferred_maintenance_window: Option<String>,
pub publicly_accessible: Option<bool>,
pub resize_info: Option<ResizeInfo>,
pub restore_status: Option<RestoreStatus>,
pub snapshot_schedule_identifier: Option<String>,
pub snapshot_schedule_state: Option<String>,
pub tags: Option<Vec<Tag>>,
pub vpc_id: Option<String>,
pub vpc_security_groups: Option<Vec<VpcSecurityGroupMembership>>,
}
#[allow(dead_code)]
struct ClusterDeserializer;
impl ClusterDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Cluster, XmlParseError> {
deserialize_elements::<_, Cluster, _>(tag_name, stack, |name, stack, obj| {
match name {
"AllowVersionUpgrade" => {
obj.allow_version_upgrade = Some(BooleanDeserializer::deserialize(
"AllowVersionUpgrade",
stack,
)?);
}
"AutomatedSnapshotRetentionPeriod" => {
obj.automated_snapshot_retention_period =
Some(IntegerDeserializer::deserialize(
"AutomatedSnapshotRetentionPeriod",
stack,
)?);
}
"AvailabilityZone" => {
obj.availability_zone =
Some(StringDeserializer::deserialize("AvailabilityZone", stack)?);
}
"ClusterAvailabilityStatus" => {
obj.cluster_availability_status = Some(StringDeserializer::deserialize(
"ClusterAvailabilityStatus",
stack,
)?);
}
"ClusterCreateTime" => {
obj.cluster_create_time =
Some(TStampDeserializer::deserialize("ClusterCreateTime", stack)?);
}
"ClusterIdentifier" => {
obj.cluster_identifier =
Some(StringDeserializer::deserialize("ClusterIdentifier", stack)?);
}
"ClusterNodes" => {
obj.cluster_nodes.get_or_insert(vec![]).extend(
ClusterNodesListDeserializer::deserialize("ClusterNodes", stack)?,
);
}
"ClusterParameterGroups" => {
obj.cluster_parameter_groups.get_or_insert(vec![]).extend(
ClusterParameterGroupStatusListDeserializer::deserialize(
"ClusterParameterGroups",
stack,
)?,
);
}
"ClusterPublicKey" => {
obj.cluster_public_key =
Some(StringDeserializer::deserialize("ClusterPublicKey", stack)?);
}
"ClusterRevisionNumber" => {
obj.cluster_revision_number = Some(StringDeserializer::deserialize(
"ClusterRevisionNumber",
stack,
)?);
}
"ClusterSecurityGroups" => {
obj.cluster_security_groups.get_or_insert(vec![]).extend(
ClusterSecurityGroupMembershipListDeserializer::deserialize(
"ClusterSecurityGroups",
stack,
)?,
);
}
"ClusterSnapshotCopyStatus" => {
obj.cluster_snapshot_copy_status =
Some(ClusterSnapshotCopyStatusDeserializer::deserialize(
"ClusterSnapshotCopyStatus",
stack,
)?);
}
"ClusterStatus" => {
obj.cluster_status =
Some(StringDeserializer::deserialize("ClusterStatus", stack)?);
}
"ClusterSubnetGroupName" => {
obj.cluster_subnet_group_name = Some(StringDeserializer::deserialize(
"ClusterSubnetGroupName",
stack,
)?);
}
"ClusterVersion" => {
obj.cluster_version =
Some(StringDeserializer::deserialize("ClusterVersion", stack)?);
}
"DBName" => {
obj.db_name = Some(StringDeserializer::deserialize("DBName", stack)?);
}
"DataTransferProgress" => {
obj.data_transfer_progress =
Some(DataTransferProgressDeserializer::deserialize(
"DataTransferProgress",
stack,
)?);
}
"DeferredMaintenanceWindows" => {
obj.deferred_maintenance_windows
.get_or_insert(vec![])
.extend(DeferredMaintenanceWindowsListDeserializer::deserialize(
"DeferredMaintenanceWindows",
stack,
)?);
}
"ElasticIpStatus" => {
obj.elastic_ip_status = Some(ElasticIpStatusDeserializer::deserialize(
"ElasticIpStatus",
stack,
)?);
}
"ElasticResizeNumberOfNodeOptions" => {
obj.elastic_resize_number_of_node_options = Some(
StringDeserializer::deserialize("ElasticResizeNumberOfNodeOptions", stack)?,
);
}
"Encrypted" => {
obj.encrypted = Some(BooleanDeserializer::deserialize("Encrypted", stack)?);
}
"Endpoint" => {
obj.endpoint = Some(EndpointDeserializer::deserialize("Endpoint", stack)?);
}
"EnhancedVpcRouting" => {
obj.enhanced_vpc_routing = Some(BooleanDeserializer::deserialize(
"EnhancedVpcRouting",
stack,
)?);
}
"ExpectedNextSnapshotScheduleTime" => {
obj.expected_next_snapshot_schedule_time = Some(
TStampDeserializer::deserialize("ExpectedNextSnapshotScheduleTime", stack)?,
);
}
"ExpectedNextSnapshotScheduleTimeStatus" => {
obj.expected_next_snapshot_schedule_time_status =
Some(StringDeserializer::deserialize(
"ExpectedNextSnapshotScheduleTimeStatus",
stack,
)?);
}
"HsmStatus" => {
obj.hsm_status = Some(HsmStatusDeserializer::deserialize("HsmStatus", stack)?);
}
"IamRoles" => {
obj.iam_roles.get_or_insert(vec![]).extend(
ClusterIamRoleListDeserializer::deserialize("IamRoles", stack)?,
);
}
"KmsKeyId" => {
obj.kms_key_id = Some(StringDeserializer::deserialize("KmsKeyId", stack)?);
}
"MaintenanceTrackName" => {
obj.maintenance_track_name = Some(StringDeserializer::deserialize(
"MaintenanceTrackName",
stack,
)?);
}
"ManualSnapshotRetentionPeriod" => {
obj.manual_snapshot_retention_period = Some(IntegerDeserializer::deserialize(
"ManualSnapshotRetentionPeriod",
stack,
)?);
}
"MasterUsername" => {
obj.master_username =
Some(StringDeserializer::deserialize("MasterUsername", stack)?);
}
"ModifyStatus" => {
obj.modify_status =
Some(StringDeserializer::deserialize("ModifyStatus", stack)?);
}
"NextMaintenanceWindowStartTime" => {
obj.next_maintenance_window_start_time = Some(TStampDeserializer::deserialize(
"NextMaintenanceWindowStartTime",
stack,
)?);
}
"NodeType" => {
obj.node_type = Some(StringDeserializer::deserialize("NodeType", stack)?);
}
"NumberOfNodes" => {
obj.number_of_nodes =
Some(IntegerDeserializer::deserialize("NumberOfNodes", stack)?);
}
"PendingActions" => {
obj.pending_actions.get_or_insert(vec![]).extend(
PendingActionsListDeserializer::deserialize("PendingActions", stack)?,
);
}
"PendingModifiedValues" => {
obj.pending_modified_values =
Some(PendingModifiedValuesDeserializer::deserialize(
"PendingModifiedValues",
stack,
)?);
}
"PreferredMaintenanceWindow" => {
obj.preferred_maintenance_window = Some(StringDeserializer::deserialize(
"PreferredMaintenanceWindow",
stack,
)?);
}
"PubliclyAccessible" => {
obj.publicly_accessible = Some(BooleanDeserializer::deserialize(
"PubliclyAccessible",
stack,
)?);
}
"ResizeInfo" => {
obj.resize_info =
Some(ResizeInfoDeserializer::deserialize("ResizeInfo", stack)?);
}
"RestoreStatus" => {
obj.restore_status = Some(RestoreStatusDeserializer::deserialize(
"RestoreStatus",
stack,
)?);
}
"SnapshotScheduleIdentifier" => {
obj.snapshot_schedule_identifier = Some(StringDeserializer::deserialize(
"SnapshotScheduleIdentifier",
stack,
)?);
}
"SnapshotScheduleState" => {
obj.snapshot_schedule_state = Some(ScheduleStateDeserializer::deserialize(
"SnapshotScheduleState",
stack,
)?);
}
"Tags" => {
obj.tags
.get_or_insert(vec![])
.extend(TagListDeserializer::deserialize("Tags", stack)?);
}
"VpcId" => {
obj.vpc_id = Some(StringDeserializer::deserialize("VpcId", stack)?);
}
"VpcSecurityGroups" => {
obj.vpc_security_groups.get_or_insert(vec![]).extend(
VpcSecurityGroupMembershipListDeserializer::deserialize(
"VpcSecurityGroups",
stack,
)?,
);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct ClusterAssociatedToSchedule {
pub cluster_identifier: Option<String>,
pub schedule_association_state: Option<String>,
}
#[allow(dead_code)]
struct ClusterAssociatedToScheduleDeserializer;
impl ClusterAssociatedToScheduleDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ClusterAssociatedToSchedule, XmlParseError> {
deserialize_elements::<_, ClusterAssociatedToSchedule, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"ClusterIdentifier" => {
obj.cluster_identifier =
Some(StringDeserializer::deserialize("ClusterIdentifier", stack)?);
}
"ScheduleAssociationState" => {
obj.schedule_association_state =
Some(ScheduleStateDeserializer::deserialize(
"ScheduleAssociationState",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct ClusterCredentials {
pub db_password: Option<String>,
pub db_user: Option<String>,
pub expiration: Option<String>,
}
#[allow(dead_code)]
struct ClusterCredentialsDeserializer;
impl ClusterCredentialsDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ClusterCredentials, XmlParseError> {
deserialize_elements::<_, ClusterCredentials, _>(tag_name, stack, |name, stack, obj| {
match name {
"DbPassword" => {
obj.db_password = Some(SensitiveStringDeserializer::deserialize(
"DbPassword",
stack,
)?);
}
"DbUser" => {
obj.db_user = Some(StringDeserializer::deserialize("DbUser", stack)?);
}
"Expiration" => {
obj.expiration = Some(TStampDeserializer::deserialize("Expiration", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct ClusterDbRevision {
pub cluster_identifier: Option<String>,
pub current_database_revision: Option<String>,
pub database_revision_release_date: Option<String>,
pub revision_targets: Option<Vec<RevisionTarget>>,
}
#[allow(dead_code)]
struct ClusterDbRevisionDeserializer;
impl ClusterDbRevisionDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ClusterDbRevision, XmlParseError> {
deserialize_elements::<_, ClusterDbRevision, _>(tag_name, stack, |name, stack, obj| {
match name {
"ClusterIdentifier" => {
obj.cluster_identifier =
Some(StringDeserializer::deserialize("ClusterIdentifier", stack)?);
}
"CurrentDatabaseRevision" => {
obj.current_database_revision = Some(StringDeserializer::deserialize(
"CurrentDatabaseRevision",
stack,
)?);
}
"DatabaseRevisionReleaseDate" => {
obj.database_revision_release_date = Some(TStampDeserializer::deserialize(
"DatabaseRevisionReleaseDate",
stack,
)?);
}
"RevisionTargets" => {
obj.revision_targets.get_or_insert(vec![]).extend(
RevisionTargetsListDeserializer::deserialize("RevisionTargets", stack)?,
);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[allow(dead_code)]
struct ClusterDbRevisionsListDeserializer;
impl ClusterDbRevisionsListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<ClusterDbRevision>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "ClusterDbRevision" {
obj.push(ClusterDbRevisionDeserializer::deserialize(
"ClusterDbRevision",
stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct ClusterDbRevisionsMessage {
pub cluster_db_revisions: Option<Vec<ClusterDbRevision>>,
pub marker: Option<String>,
}
#[allow(dead_code)]
struct ClusterDbRevisionsMessageDeserializer;
impl ClusterDbRevisionsMessageDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ClusterDbRevisionsMessage, XmlParseError> {
deserialize_elements::<_, ClusterDbRevisionsMessage, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"ClusterDbRevisions" => {
obj.cluster_db_revisions.get_or_insert(vec![]).extend(
ClusterDbRevisionsListDeserializer::deserialize(
"ClusterDbRevisions",
stack,
)?,
);
}
"Marker" => {
obj.marker = Some(StringDeserializer::deserialize("Marker", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct ClusterIamRole {
pub apply_status: Option<String>,
pub iam_role_arn: Option<String>,
}
#[allow(dead_code)]
struct ClusterIamRoleDeserializer;
impl ClusterIamRoleDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ClusterIamRole, XmlParseError> {
deserialize_elements::<_, ClusterIamRole, _>(tag_name, stack, |name, stack, obj| {
match name {
"ApplyStatus" => {
obj.apply_status = Some(StringDeserializer::deserialize("ApplyStatus", stack)?);
}
"IamRoleArn" => {
obj.iam_role_arn = Some(StringDeserializer::deserialize("IamRoleArn", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[allow(dead_code)]
struct ClusterIamRoleListDeserializer;
impl ClusterIamRoleListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<ClusterIamRole>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "ClusterIamRole" {
obj.push(ClusterIamRoleDeserializer::deserialize(
"ClusterIamRole",
stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[allow(dead_code)]
struct ClusterListDeserializer;
impl ClusterListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<Cluster>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "Cluster" {
obj.push(ClusterDeserializer::deserialize("Cluster", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct ClusterNode {
pub node_role: Option<String>,
pub private_ip_address: Option<String>,
pub public_ip_address: Option<String>,
}
#[allow(dead_code)]
struct ClusterNodeDeserializer;
impl ClusterNodeDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ClusterNode, XmlParseError> {
deserialize_elements::<_, ClusterNode, _>(tag_name, stack, |name, stack, obj| {
match name {
"NodeRole" => {
obj.node_role = Some(StringDeserializer::deserialize("NodeRole", stack)?);
}
"PrivateIPAddress" => {
obj.private_ip_address =
Some(StringDeserializer::deserialize("PrivateIPAddress", stack)?);
}
"PublicIPAddress" => {
obj.public_ip_address =
Some(StringDeserializer::deserialize("PublicIPAddress", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[allow(dead_code)]
struct ClusterNodesListDeserializer;
impl ClusterNodesListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<ClusterNode>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "member" {
obj.push(ClusterNodeDeserializer::deserialize("member", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct ClusterParameterGroup {
pub description: Option<String>,
pub parameter_group_family: Option<String>,
pub parameter_group_name: Option<String>,
pub tags: Option<Vec<Tag>>,
}
#[allow(dead_code)]
struct ClusterParameterGroupDeserializer;
impl ClusterParameterGroupDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ClusterParameterGroup, XmlParseError> {
deserialize_elements::<_, ClusterParameterGroup, _>(tag_name, stack, |name, stack, obj| {
match name {
"Description" => {
obj.description = Some(StringDeserializer::deserialize("Description", stack)?);
}
"ParameterGroupFamily" => {
obj.parameter_group_family = Some(StringDeserializer::deserialize(
"ParameterGroupFamily",
stack,
)?);
}
"ParameterGroupName" => {
obj.parameter_group_name = Some(StringDeserializer::deserialize(
"ParameterGroupName",
stack,
)?);
}
"Tags" => {
obj.tags
.get_or_insert(vec![])
.extend(TagListDeserializer::deserialize("Tags", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct ClusterParameterGroupDetails {
pub marker: Option<String>,
pub parameters: Option<Vec<Parameter>>,
}
#[allow(dead_code)]
struct ClusterParameterGroupDetailsDeserializer;
impl ClusterParameterGroupDetailsDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ClusterParameterGroupDetails, XmlParseError> {
deserialize_elements::<_, ClusterParameterGroupDetails, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"Marker" => {
obj.marker = Some(StringDeserializer::deserialize("Marker", stack)?);
}
"Parameters" => {
obj.parameters.get_or_insert(vec![]).extend(
ParametersListDeserializer::deserialize("Parameters", stack)?,
);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct ClusterParameterGroupNameMessage {
pub parameter_group_name: Option<String>,
pub parameter_group_status: Option<String>,
}
#[allow(dead_code)]
struct ClusterParameterGroupNameMessageDeserializer;
impl ClusterParameterGroupNameMessageDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ClusterParameterGroupNameMessage, XmlParseError> {
deserialize_elements::<_, ClusterParameterGroupNameMessage, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"ParameterGroupName" => {
obj.parameter_group_name = Some(StringDeserializer::deserialize(
"ParameterGroupName",
stack,
)?);
}
"ParameterGroupStatus" => {
obj.parameter_group_status = Some(StringDeserializer::deserialize(
"ParameterGroupStatus",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct ClusterParameterGroupStatus {
pub cluster_parameter_status_list: Option<Vec<ClusterParameterStatus>>,
pub parameter_apply_status: Option<String>,
pub parameter_group_name: Option<String>,
}
#[allow(dead_code)]
struct ClusterParameterGroupStatusDeserializer;
impl ClusterParameterGroupStatusDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ClusterParameterGroupStatus, XmlParseError> {
deserialize_elements::<_, ClusterParameterGroupStatus, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"ClusterParameterStatusList" => {
obj.cluster_parameter_status_list
.get_or_insert(vec![])
.extend(ClusterParameterStatusListDeserializer::deserialize(
"ClusterParameterStatusList",
stack,
)?);
}
"ParameterApplyStatus" => {
obj.parameter_apply_status = Some(StringDeserializer::deserialize(
"ParameterApplyStatus",
stack,
)?);
}
"ParameterGroupName" => {
obj.parameter_group_name = Some(StringDeserializer::deserialize(
"ParameterGroupName",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[allow(dead_code)]
struct ClusterParameterGroupStatusListDeserializer;
impl ClusterParameterGroupStatusListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<ClusterParameterGroupStatus>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "ClusterParameterGroup" {
obj.push(ClusterParameterGroupStatusDeserializer::deserialize(
"ClusterParameterGroup",
stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct ClusterParameterGroupsMessage {
pub marker: Option<String>,
pub parameter_groups: Option<Vec<ClusterParameterGroup>>,
}
#[allow(dead_code)]
struct ClusterParameterGroupsMessageDeserializer;
impl ClusterParameterGroupsMessageDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ClusterParameterGroupsMessage, XmlParseError> {
deserialize_elements::<_, ClusterParameterGroupsMessage, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"Marker" => {
obj.marker = Some(StringDeserializer::deserialize("Marker", stack)?);
}
"ParameterGroups" => {
obj.parameter_groups.get_or_insert(vec![]).extend(
ParameterGroupListDeserializer::deserialize("ParameterGroups", stack)?,
);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct ClusterParameterStatus {
pub parameter_apply_error_description: Option<String>,
pub parameter_apply_status: Option<String>,
pub parameter_name: Option<String>,
}
#[allow(dead_code)]
struct ClusterParameterStatusDeserializer;
impl ClusterParameterStatusDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ClusterParameterStatus, XmlParseError> {
deserialize_elements::<_, ClusterParameterStatus, _>(tag_name, stack, |name, stack, obj| {
match name {
"ParameterApplyErrorDescription" => {
obj.parameter_apply_error_description = Some(StringDeserializer::deserialize(
"ParameterApplyErrorDescription",
stack,
)?);
}
"ParameterApplyStatus" => {
obj.parameter_apply_status = Some(StringDeserializer::deserialize(
"ParameterApplyStatus",
stack,
)?);
}
"ParameterName" => {
obj.parameter_name =
Some(StringDeserializer::deserialize("ParameterName", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[allow(dead_code)]
struct ClusterParameterStatusListDeserializer;
impl ClusterParameterStatusListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<ClusterParameterStatus>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "member" {
obj.push(ClusterParameterStatusDeserializer::deserialize(
"member", stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct ClusterSecurityGroup {
pub cluster_security_group_name: Option<String>,
pub description: Option<String>,
pub ec2_security_groups: Option<Vec<EC2SecurityGroup>>,
pub ip_ranges: Option<Vec<IPRange>>,
pub tags: Option<Vec<Tag>>,
}
#[allow(dead_code)]
struct ClusterSecurityGroupDeserializer;
impl ClusterSecurityGroupDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ClusterSecurityGroup, XmlParseError> {
deserialize_elements::<_, ClusterSecurityGroup, _>(tag_name, stack, |name, stack, obj| {
match name {
"ClusterSecurityGroupName" => {
obj.cluster_security_group_name = Some(StringDeserializer::deserialize(
"ClusterSecurityGroupName",
stack,
)?);
}
"Description" => {
obj.description = Some(StringDeserializer::deserialize("Description", stack)?);
}
"EC2SecurityGroups" => {
obj.ec2_security_groups.get_or_insert(vec![]).extend(
EC2SecurityGroupListDeserializer::deserialize("EC2SecurityGroups", stack)?,
);
}
"IPRanges" => {
obj.ip_ranges
.get_or_insert(vec![])
.extend(IPRangeListDeserializer::deserialize("IPRanges", stack)?);
}
"Tags" => {
obj.tags
.get_or_insert(vec![])
.extend(TagListDeserializer::deserialize("Tags", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct ClusterSecurityGroupMembership {
pub cluster_security_group_name: Option<String>,
pub status: Option<String>,
}
#[allow(dead_code)]
struct ClusterSecurityGroupMembershipDeserializer;
impl ClusterSecurityGroupMembershipDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ClusterSecurityGroupMembership, XmlParseError> {
deserialize_elements::<_, ClusterSecurityGroupMembership, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"ClusterSecurityGroupName" => {
obj.cluster_security_group_name = Some(StringDeserializer::deserialize(
"ClusterSecurityGroupName",
stack,
)?);
}
"Status" => {
obj.status = Some(StringDeserializer::deserialize("Status", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[allow(dead_code)]
struct ClusterSecurityGroupMembershipListDeserializer;
impl ClusterSecurityGroupMembershipListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<ClusterSecurityGroupMembership>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "ClusterSecurityGroup" {
obj.push(ClusterSecurityGroupMembershipDeserializer::deserialize(
"ClusterSecurityGroup",
stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct ClusterSecurityGroupMessage {
pub cluster_security_groups: Option<Vec<ClusterSecurityGroup>>,
pub marker: Option<String>,
}
#[allow(dead_code)]
struct ClusterSecurityGroupMessageDeserializer;
impl ClusterSecurityGroupMessageDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ClusterSecurityGroupMessage, XmlParseError> {
deserialize_elements::<_, ClusterSecurityGroupMessage, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"ClusterSecurityGroups" => {
obj.cluster_security_groups.get_or_insert(vec![]).extend(
ClusterSecurityGroupsDeserializer::deserialize(
"ClusterSecurityGroups",
stack,
)?,
);
}
"Marker" => {
obj.marker = Some(StringDeserializer::deserialize("Marker", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
struct ClusterSecurityGroupNameListSerializer;
impl ClusterSecurityGroupNameListSerializer {
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 ClusterSecurityGroupsDeserializer;
impl ClusterSecurityGroupsDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<ClusterSecurityGroup>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "ClusterSecurityGroup" {
obj.push(ClusterSecurityGroupDeserializer::deserialize(
"ClusterSecurityGroup",
stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct ClusterSnapshotCopyStatus {
pub destination_region: Option<String>,
pub manual_snapshot_retention_period: Option<i64>,
pub retention_period: Option<i64>,
pub snapshot_copy_grant_name: Option<String>,
}
#[allow(dead_code)]
struct ClusterSnapshotCopyStatusDeserializer;
impl ClusterSnapshotCopyStatusDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ClusterSnapshotCopyStatus, XmlParseError> {
deserialize_elements::<_, ClusterSnapshotCopyStatus, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"DestinationRegion" => {
obj.destination_region =
Some(StringDeserializer::deserialize("DestinationRegion", stack)?);
}
"ManualSnapshotRetentionPeriod" => {
obj.manual_snapshot_retention_period =
Some(IntegerDeserializer::deserialize(
"ManualSnapshotRetentionPeriod",
stack,
)?);
}
"RetentionPeriod" => {
obj.retention_period =
Some(LongDeserializer::deserialize("RetentionPeriod", stack)?);
}
"SnapshotCopyGrantName" => {
obj.snapshot_copy_grant_name = Some(StringDeserializer::deserialize(
"SnapshotCopyGrantName",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct ClusterSubnetGroup {
pub cluster_subnet_group_name: Option<String>,
pub description: Option<String>,
pub subnet_group_status: Option<String>,
pub subnets: Option<Vec<Subnet>>,
pub tags: Option<Vec<Tag>>,
pub vpc_id: Option<String>,
}
#[allow(dead_code)]
struct ClusterSubnetGroupDeserializer;
impl ClusterSubnetGroupDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ClusterSubnetGroup, XmlParseError> {
deserialize_elements::<_, ClusterSubnetGroup, _>(tag_name, stack, |name, stack, obj| {
match name {
"ClusterSubnetGroupName" => {
obj.cluster_subnet_group_name = Some(StringDeserializer::deserialize(
"ClusterSubnetGroupName",
stack,
)?);
}
"Description" => {
obj.description = Some(StringDeserializer::deserialize("Description", stack)?);
}
"SubnetGroupStatus" => {
obj.subnet_group_status =
Some(StringDeserializer::deserialize("SubnetGroupStatus", stack)?);
}
"Subnets" => {
obj.subnets
.get_or_insert(vec![])
.extend(SubnetListDeserializer::deserialize("Subnets", stack)?);
}
"Tags" => {
obj.tags
.get_or_insert(vec![])
.extend(TagListDeserializer::deserialize("Tags", stack)?);
}
"VpcId" => {
obj.vpc_id = Some(StringDeserializer::deserialize("VpcId", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct ClusterSubnetGroupMessage {
pub cluster_subnet_groups: Option<Vec<ClusterSubnetGroup>>,
pub marker: Option<String>,
}
#[allow(dead_code)]
struct ClusterSubnetGroupMessageDeserializer;
impl ClusterSubnetGroupMessageDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ClusterSubnetGroupMessage, XmlParseError> {
deserialize_elements::<_, ClusterSubnetGroupMessage, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"ClusterSubnetGroups" => {
obj.cluster_subnet_groups.get_or_insert(vec![]).extend(
ClusterSubnetGroupsDeserializer::deserialize(
"ClusterSubnetGroups",
stack,
)?,
);
}
"Marker" => {
obj.marker = Some(StringDeserializer::deserialize("Marker", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[allow(dead_code)]
struct ClusterSubnetGroupsDeserializer;
impl ClusterSubnetGroupsDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<ClusterSubnetGroup>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "ClusterSubnetGroup" {
obj.push(ClusterSubnetGroupDeserializer::deserialize(
"ClusterSubnetGroup",
stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct ClusterVersion {
pub cluster_parameter_group_family: Option<String>,
pub cluster_version: Option<String>,
pub description: Option<String>,
}
#[allow(dead_code)]
struct ClusterVersionDeserializer;
impl ClusterVersionDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ClusterVersion, XmlParseError> {
deserialize_elements::<_, ClusterVersion, _>(tag_name, stack, |name, stack, obj| {
match name {
"ClusterParameterGroupFamily" => {
obj.cluster_parameter_group_family = Some(StringDeserializer::deserialize(
"ClusterParameterGroupFamily",
stack,
)?);
}
"ClusterVersion" => {
obj.cluster_version =
Some(StringDeserializer::deserialize("ClusterVersion", stack)?);
}
"Description" => {
obj.description = Some(StringDeserializer::deserialize("Description", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[allow(dead_code)]
struct ClusterVersionListDeserializer;
impl ClusterVersionListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<ClusterVersion>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "ClusterVersion" {
obj.push(ClusterVersionDeserializer::deserialize(
"ClusterVersion",
stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct ClusterVersionsMessage {
pub cluster_versions: Option<Vec<ClusterVersion>>,
pub marker: Option<String>,
}
#[allow(dead_code)]
struct ClusterVersionsMessageDeserializer;
impl ClusterVersionsMessageDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ClusterVersionsMessage, XmlParseError> {
deserialize_elements::<_, ClusterVersionsMessage, _>(tag_name, stack, |name, stack, obj| {
match name {
"ClusterVersions" => {
obj.cluster_versions.get_or_insert(vec![]).extend(
ClusterVersionListDeserializer::deserialize("ClusterVersions", stack)?,
);
}
"Marker" => {
obj.marker = Some(StringDeserializer::deserialize("Marker", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct ClustersMessage {
pub clusters: Option<Vec<Cluster>>,
pub marker: Option<String>,
}
#[allow(dead_code)]
struct ClustersMessageDeserializer;
impl ClustersMessageDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ClustersMessage, XmlParseError> {
deserialize_elements::<_, ClustersMessage, _>(tag_name, stack, |name, stack, obj| {
match name {
"Clusters" => {
obj.clusters
.get_or_insert(vec![])
.extend(ClusterListDeserializer::deserialize("Clusters", stack)?);
}
"Marker" => {
obj.marker = Some(StringDeserializer::deserialize("Marker", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CopyClusterSnapshotMessage {
pub manual_snapshot_retention_period: Option<i64>,
pub source_snapshot_cluster_identifier: Option<String>,
pub source_snapshot_identifier: String,
pub target_snapshot_identifier: String,
}
struct CopyClusterSnapshotMessageSerializer;
impl CopyClusterSnapshotMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CopyClusterSnapshotMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.manual_snapshot_retention_period {
params.put(
&format!("{}{}", prefix, "ManualSnapshotRetentionPeriod"),
&field_value,
);
}
if let Some(ref field_value) = obj.source_snapshot_cluster_identifier {
params.put(
&format!("{}{}", prefix, "SourceSnapshotClusterIdentifier"),
&field_value,
);
}
params.put(
&format!("{}{}", prefix, "SourceSnapshotIdentifier"),
&obj.source_snapshot_identifier,
);
params.put(
&format!("{}{}", prefix, "TargetSnapshotIdentifier"),
&obj.target_snapshot_identifier,
);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct CopyClusterSnapshotResult {
pub snapshot: Option<Snapshot>,
}
#[allow(dead_code)]
struct CopyClusterSnapshotResultDeserializer;
impl CopyClusterSnapshotResultDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CopyClusterSnapshotResult, XmlParseError> {
deserialize_elements::<_, CopyClusterSnapshotResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"Snapshot" => {
obj.snapshot = Some(SnapshotDeserializer::deserialize("Snapshot", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateClusterMessage {
pub additional_info: Option<String>,
pub allow_version_upgrade: Option<bool>,
pub automated_snapshot_retention_period: Option<i64>,
pub availability_zone: Option<String>,
pub cluster_identifier: String,
pub cluster_parameter_group_name: Option<String>,
pub cluster_security_groups: Option<Vec<String>>,
pub cluster_subnet_group_name: Option<String>,
pub cluster_type: Option<String>,
pub cluster_version: Option<String>,
pub db_name: Option<String>,
pub elastic_ip: Option<String>,
pub encrypted: Option<bool>,
pub enhanced_vpc_routing: Option<bool>,
pub hsm_client_certificate_identifier: Option<String>,
pub hsm_configuration_identifier: Option<String>,
pub iam_roles: Option<Vec<String>>,
pub kms_key_id: Option<String>,
pub maintenance_track_name: Option<String>,
pub manual_snapshot_retention_period: Option<i64>,
pub master_user_password: String,
pub master_username: String,
pub node_type: String,
pub number_of_nodes: Option<i64>,
pub port: Option<i64>,
pub preferred_maintenance_window: Option<String>,
pub publicly_accessible: Option<bool>,
pub snapshot_schedule_identifier: Option<String>,
pub tags: Option<Vec<Tag>>,
pub vpc_security_group_ids: Option<Vec<String>>,
}
struct CreateClusterMessageSerializer;
impl CreateClusterMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CreateClusterMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.additional_info {
params.put(&format!("{}{}", prefix, "AdditionalInfo"), &field_value);
}
if let Some(ref field_value) = obj.allow_version_upgrade {
params.put(
&format!("{}{}", prefix, "AllowVersionUpgrade"),
&field_value,
);
}
if let Some(ref field_value) = obj.automated_snapshot_retention_period {
params.put(
&format!("{}{}", prefix, "AutomatedSnapshotRetentionPeriod"),
&field_value,
);
}
if let Some(ref field_value) = obj.availability_zone {
params.put(&format!("{}{}", prefix, "AvailabilityZone"), &field_value);
}
params.put(
&format!("{}{}", prefix, "ClusterIdentifier"),
&obj.cluster_identifier,
);
if let Some(ref field_value) = obj.cluster_parameter_group_name {
params.put(
&format!("{}{}", prefix, "ClusterParameterGroupName"),
&field_value,
);
}
if let Some(ref field_value) = obj.cluster_security_groups {
ClusterSecurityGroupNameListSerializer::serialize(
params,
&format!("{}{}", prefix, "ClusterSecurityGroupName"),
field_value,
);
}
if let Some(ref field_value) = obj.cluster_subnet_group_name {
params.put(
&format!("{}{}", prefix, "ClusterSubnetGroupName"),
&field_value,
);
}
if let Some(ref field_value) = obj.cluster_type {
params.put(&format!("{}{}", prefix, "ClusterType"), &field_value);
}
if let Some(ref field_value) = obj.cluster_version {
params.put(&format!("{}{}", prefix, "ClusterVersion"), &field_value);
}
if let Some(ref field_value) = obj.db_name {
params.put(&format!("{}{}", prefix, "DBName"), &field_value);
}
if let Some(ref field_value) = obj.elastic_ip {
params.put(&format!("{}{}", prefix, "ElasticIp"), &field_value);
}
if let Some(ref field_value) = obj.encrypted {
params.put(&format!("{}{}", prefix, "Encrypted"), &field_value);
}
if let Some(ref field_value) = obj.enhanced_vpc_routing {
params.put(&format!("{}{}", prefix, "EnhancedVpcRouting"), &field_value);
}
if let Some(ref field_value) = obj.hsm_client_certificate_identifier {
params.put(
&format!("{}{}", prefix, "HsmClientCertificateIdentifier"),
&field_value,
);
}
if let Some(ref field_value) = obj.hsm_configuration_identifier {
params.put(
&format!("{}{}", prefix, "HsmConfigurationIdentifier"),
&field_value,
);
}
if let Some(ref field_value) = obj.iam_roles {
IamRoleArnListSerializer::serialize(
params,
&format!("{}{}", prefix, "IamRoleArn"),
field_value,
);
}
if let Some(ref field_value) = obj.kms_key_id {
params.put(&format!("{}{}", prefix, "KmsKeyId"), &field_value);
}
if let Some(ref field_value) = obj.maintenance_track_name {
params.put(
&format!("{}{}", prefix, "MaintenanceTrackName"),
&field_value,
);
}
if let Some(ref field_value) = obj.manual_snapshot_retention_period {
params.put(
&format!("{}{}", prefix, "ManualSnapshotRetentionPeriod"),
&field_value,
);
}
params.put(
&format!("{}{}", prefix, "MasterUserPassword"),
&obj.master_user_password,
);
params.put(
&format!("{}{}", prefix, "MasterUsername"),
&obj.master_username,
);
params.put(&format!("{}{}", prefix, "NodeType"), &obj.node_type);
if let Some(ref field_value) = obj.number_of_nodes {
params.put(&format!("{}{}", prefix, "NumberOfNodes"), &field_value);
}
if let Some(ref field_value) = obj.port {
params.put(&format!("{}{}", prefix, "Port"), &field_value);
}
if let Some(ref field_value) = obj.preferred_maintenance_window {
params.put(
&format!("{}{}", prefix, "PreferredMaintenanceWindow"),
&field_value,
);
}
if let Some(ref field_value) = obj.publicly_accessible {
params.put(&format!("{}{}", prefix, "PubliclyAccessible"), &field_value);
}
if let Some(ref field_value) = obj.snapshot_schedule_identifier {
params.put(
&format!("{}{}", prefix, "SnapshotScheduleIdentifier"),
&field_value,
);
}
if let Some(ref field_value) = obj.tags {
TagListSerializer::serialize(params, &format!("{}{}", prefix, "Tag"), field_value);
}
if let Some(ref field_value) = obj.vpc_security_group_ids {
VpcSecurityGroupIdListSerializer::serialize(
params,
&format!("{}{}", prefix, "VpcSecurityGroupId"),
field_value,
);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateClusterParameterGroupMessage {
pub description: String,
pub parameter_group_family: String,
pub parameter_group_name: String,
pub tags: Option<Vec<Tag>>,
}
struct CreateClusterParameterGroupMessageSerializer;
impl CreateClusterParameterGroupMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CreateClusterParameterGroupMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(&format!("{}{}", prefix, "Description"), &obj.description);
params.put(
&format!("{}{}", prefix, "ParameterGroupFamily"),
&obj.parameter_group_family,
);
params.put(
&format!("{}{}", prefix, "ParameterGroupName"),
&obj.parameter_group_name,
);
if let Some(ref field_value) = obj.tags {
TagListSerializer::serialize(params, &format!("{}{}", prefix, "Tag"), field_value);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct CreateClusterParameterGroupResult {
pub cluster_parameter_group: Option<ClusterParameterGroup>,
}
#[allow(dead_code)]
struct CreateClusterParameterGroupResultDeserializer;
impl CreateClusterParameterGroupResultDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CreateClusterParameterGroupResult, XmlParseError> {
deserialize_elements::<_, CreateClusterParameterGroupResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"ClusterParameterGroup" => {
obj.cluster_parameter_group =
Some(ClusterParameterGroupDeserializer::deserialize(
"ClusterParameterGroup",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct CreateClusterResult {
pub cluster: Option<Cluster>,
}
#[allow(dead_code)]
struct CreateClusterResultDeserializer;
impl CreateClusterResultDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CreateClusterResult, XmlParseError> {
deserialize_elements::<_, CreateClusterResult, _>(tag_name, stack, |name, stack, obj| {
match name {
"Cluster" => {
obj.cluster = Some(ClusterDeserializer::deserialize("Cluster", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateClusterSecurityGroupMessage {
pub cluster_security_group_name: String,
pub description: String,
pub tags: Option<Vec<Tag>>,
}
struct CreateClusterSecurityGroupMessageSerializer;
impl CreateClusterSecurityGroupMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CreateClusterSecurityGroupMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "ClusterSecurityGroupName"),
&obj.cluster_security_group_name,
);
params.put(&format!("{}{}", prefix, "Description"), &obj.description);
if let Some(ref field_value) = obj.tags {
TagListSerializer::serialize(params, &format!("{}{}", prefix, "Tag"), field_value);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct CreateClusterSecurityGroupResult {
pub cluster_security_group: Option<ClusterSecurityGroup>,
}
#[allow(dead_code)]
struct CreateClusterSecurityGroupResultDeserializer;
impl CreateClusterSecurityGroupResultDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CreateClusterSecurityGroupResult, XmlParseError> {
deserialize_elements::<_, CreateClusterSecurityGroupResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"ClusterSecurityGroup" => {
obj.cluster_security_group =
Some(ClusterSecurityGroupDeserializer::deserialize(
"ClusterSecurityGroup",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateClusterSnapshotMessage {
pub cluster_identifier: String,
pub manual_snapshot_retention_period: Option<i64>,
pub snapshot_identifier: String,
pub tags: Option<Vec<Tag>>,
}
struct CreateClusterSnapshotMessageSerializer;
impl CreateClusterSnapshotMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CreateClusterSnapshotMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "ClusterIdentifier"),
&obj.cluster_identifier,
);
if let Some(ref field_value) = obj.manual_snapshot_retention_period {
params.put(
&format!("{}{}", prefix, "ManualSnapshotRetentionPeriod"),
&field_value,
);
}
params.put(
&format!("{}{}", prefix, "SnapshotIdentifier"),
&obj.snapshot_identifier,
);
if let Some(ref field_value) = obj.tags {
TagListSerializer::serialize(params, &format!("{}{}", prefix, "Tag"), field_value);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct CreateClusterSnapshotResult {
pub snapshot: Option<Snapshot>,
}
#[allow(dead_code)]
struct CreateClusterSnapshotResultDeserializer;
impl CreateClusterSnapshotResultDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CreateClusterSnapshotResult, XmlParseError> {
deserialize_elements::<_, CreateClusterSnapshotResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"Snapshot" => {
obj.snapshot = Some(SnapshotDeserializer::deserialize("Snapshot", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateClusterSubnetGroupMessage {
pub cluster_subnet_group_name: String,
pub description: String,
pub subnet_ids: Vec<String>,
pub tags: Option<Vec<Tag>>,
}
struct CreateClusterSubnetGroupMessageSerializer;
impl CreateClusterSubnetGroupMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CreateClusterSubnetGroupMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "ClusterSubnetGroupName"),
&obj.cluster_subnet_group_name,
);
params.put(&format!("{}{}", prefix, "Description"), &obj.description);
SubnetIdentifierListSerializer::serialize(
params,
&format!("{}{}", prefix, "SubnetIdentifier"),
&obj.subnet_ids,
);
if let Some(ref field_value) = obj.tags {
TagListSerializer::serialize(params, &format!("{}{}", prefix, "Tag"), field_value);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct CreateClusterSubnetGroupResult {
pub cluster_subnet_group: Option<ClusterSubnetGroup>,
}
#[allow(dead_code)]
struct CreateClusterSubnetGroupResultDeserializer;
impl CreateClusterSubnetGroupResultDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CreateClusterSubnetGroupResult, XmlParseError> {
deserialize_elements::<_, CreateClusterSubnetGroupResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"ClusterSubnetGroup" => {
obj.cluster_subnet_group =
Some(ClusterSubnetGroupDeserializer::deserialize(
"ClusterSubnetGroup",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateEventSubscriptionMessage {
pub enabled: Option<bool>,
pub event_categories: Option<Vec<String>>,
pub severity: Option<String>,
pub sns_topic_arn: String,
pub source_ids: Option<Vec<String>>,
pub source_type: Option<String>,
pub subscription_name: String,
pub tags: Option<Vec<Tag>>,
}
struct CreateEventSubscriptionMessageSerializer;
impl CreateEventSubscriptionMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CreateEventSubscriptionMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.enabled {
params.put(&format!("{}{}", prefix, "Enabled"), &field_value);
}
if let Some(ref field_value) = obj.event_categories {
EventCategoriesListSerializer::serialize(
params,
&format!("{}{}", prefix, "EventCategory"),
field_value,
);
}
if let Some(ref field_value) = obj.severity {
params.put(&format!("{}{}", prefix, "Severity"), &field_value);
}
params.put(&format!("{}{}", prefix, "SnsTopicArn"), &obj.sns_topic_arn);
if let Some(ref field_value) = obj.source_ids {
SourceIdsListSerializer::serialize(
params,
&format!("{}{}", prefix, "SourceId"),
field_value,
);
}
if let Some(ref field_value) = obj.source_type {
params.put(&format!("{}{}", prefix, "SourceType"), &field_value);
}
params.put(
&format!("{}{}", prefix, "SubscriptionName"),
&obj.subscription_name,
);
if let Some(ref field_value) = obj.tags {
TagListSerializer::serialize(params, &format!("{}{}", prefix, "Tag"), field_value);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct CreateEventSubscriptionResult {
pub event_subscription: Option<EventSubscription>,
}
#[allow(dead_code)]
struct CreateEventSubscriptionResultDeserializer;
impl CreateEventSubscriptionResultDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CreateEventSubscriptionResult, XmlParseError> {
deserialize_elements::<_, CreateEventSubscriptionResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"EventSubscription" => {
obj.event_subscription = Some(EventSubscriptionDeserializer::deserialize(
"EventSubscription",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateHsmClientCertificateMessage {
pub hsm_client_certificate_identifier: String,
pub tags: Option<Vec<Tag>>,
}
struct CreateHsmClientCertificateMessageSerializer;
impl CreateHsmClientCertificateMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CreateHsmClientCertificateMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "HsmClientCertificateIdentifier"),
&obj.hsm_client_certificate_identifier,
);
if let Some(ref field_value) = obj.tags {
TagListSerializer::serialize(params, &format!("{}{}", prefix, "Tag"), field_value);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct CreateHsmClientCertificateResult {
pub hsm_client_certificate: Option<HsmClientCertificate>,
}
#[allow(dead_code)]
struct CreateHsmClientCertificateResultDeserializer;
impl CreateHsmClientCertificateResultDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CreateHsmClientCertificateResult, XmlParseError> {
deserialize_elements::<_, CreateHsmClientCertificateResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"HsmClientCertificate" => {
obj.hsm_client_certificate =
Some(HsmClientCertificateDeserializer::deserialize(
"HsmClientCertificate",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateHsmConfigurationMessage {
pub description: String,
pub hsm_configuration_identifier: String,
pub hsm_ip_address: String,
pub hsm_partition_name: String,
pub hsm_partition_password: String,
pub hsm_server_public_certificate: String,
pub tags: Option<Vec<Tag>>,
}
struct CreateHsmConfigurationMessageSerializer;
impl CreateHsmConfigurationMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CreateHsmConfigurationMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(&format!("{}{}", prefix, "Description"), &obj.description);
params.put(
&format!("{}{}", prefix, "HsmConfigurationIdentifier"),
&obj.hsm_configuration_identifier,
);
params.put(
&format!("{}{}", prefix, "HsmIpAddress"),
&obj.hsm_ip_address,
);
params.put(
&format!("{}{}", prefix, "HsmPartitionName"),
&obj.hsm_partition_name,
);
params.put(
&format!("{}{}", prefix, "HsmPartitionPassword"),
&obj.hsm_partition_password,
);
params.put(
&format!("{}{}", prefix, "HsmServerPublicCertificate"),
&obj.hsm_server_public_certificate,
);
if let Some(ref field_value) = obj.tags {
TagListSerializer::serialize(params, &format!("{}{}", prefix, "Tag"), field_value);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct CreateHsmConfigurationResult {
pub hsm_configuration: Option<HsmConfiguration>,
}
#[allow(dead_code)]
struct CreateHsmConfigurationResultDeserializer;
impl CreateHsmConfigurationResultDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CreateHsmConfigurationResult, XmlParseError> {
deserialize_elements::<_, CreateHsmConfigurationResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"HsmConfiguration" => {
obj.hsm_configuration = Some(HsmConfigurationDeserializer::deserialize(
"HsmConfiguration",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateScheduledActionMessage {
pub enable: Option<bool>,
pub end_time: Option<String>,
pub iam_role: String,
pub schedule: String,
pub scheduled_action_description: Option<String>,
pub scheduled_action_name: String,
pub start_time: Option<String>,
pub target_action: ScheduledActionType,
}
struct CreateScheduledActionMessageSerializer;
impl CreateScheduledActionMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CreateScheduledActionMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.enable {
params.put(&format!("{}{}", prefix, "Enable"), &field_value);
}
if let Some(ref field_value) = obj.end_time {
params.put(&format!("{}{}", prefix, "EndTime"), &field_value);
}
params.put(&format!("{}{}", prefix, "IamRole"), &obj.iam_role);
params.put(&format!("{}{}", prefix, "Schedule"), &obj.schedule);
if let Some(ref field_value) = obj.scheduled_action_description {
params.put(
&format!("{}{}", prefix, "ScheduledActionDescription"),
&field_value,
);
}
params.put(
&format!("{}{}", prefix, "ScheduledActionName"),
&obj.scheduled_action_name,
);
if let Some(ref field_value) = obj.start_time {
params.put(&format!("{}{}", prefix, "StartTime"), &field_value);
}
ScheduledActionTypeSerializer::serialize(
params,
&format!("{}{}", prefix, "TargetAction"),
&obj.target_action,
);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateSnapshotCopyGrantMessage {
pub kms_key_id: Option<String>,
pub snapshot_copy_grant_name: String,
pub tags: Option<Vec<Tag>>,
}
struct CreateSnapshotCopyGrantMessageSerializer;
impl CreateSnapshotCopyGrantMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CreateSnapshotCopyGrantMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.kms_key_id {
params.put(&format!("{}{}", prefix, "KmsKeyId"), &field_value);
}
params.put(
&format!("{}{}", prefix, "SnapshotCopyGrantName"),
&obj.snapshot_copy_grant_name,
);
if let Some(ref field_value) = obj.tags {
TagListSerializer::serialize(params, &format!("{}{}", prefix, "Tag"), field_value);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct CreateSnapshotCopyGrantResult {
pub snapshot_copy_grant: Option<SnapshotCopyGrant>,
}
#[allow(dead_code)]
struct CreateSnapshotCopyGrantResultDeserializer;
impl CreateSnapshotCopyGrantResultDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CreateSnapshotCopyGrantResult, XmlParseError> {
deserialize_elements::<_, CreateSnapshotCopyGrantResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"SnapshotCopyGrant" => {
obj.snapshot_copy_grant = Some(SnapshotCopyGrantDeserializer::deserialize(
"SnapshotCopyGrant",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateSnapshotScheduleMessage {
pub dry_run: Option<bool>,
pub next_invocations: Option<i64>,
pub schedule_definitions: Option<Vec<String>>,
pub schedule_description: Option<String>,
pub schedule_identifier: Option<String>,
pub tags: Option<Vec<Tag>>,
}
struct CreateSnapshotScheduleMessageSerializer;
impl CreateSnapshotScheduleMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CreateSnapshotScheduleMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.dry_run {
params.put(&format!("{}{}", prefix, "DryRun"), &field_value);
}
if let Some(ref field_value) = obj.next_invocations {
params.put(&format!("{}{}", prefix, "NextInvocations"), &field_value);
}
if let Some(ref field_value) = obj.schedule_definitions {
ScheduleDefinitionListSerializer::serialize(
params,
&format!("{}{}", prefix, "ScheduleDefinition"),
field_value,
);
}
if let Some(ref field_value) = obj.schedule_description {
params.put(
&format!("{}{}", prefix, "ScheduleDescription"),
&field_value,
);
}
if let Some(ref field_value) = obj.schedule_identifier {
params.put(&format!("{}{}", prefix, "ScheduleIdentifier"), &field_value);
}
if let Some(ref field_value) = obj.tags {
TagListSerializer::serialize(params, &format!("{}{}", prefix, "Tag"), field_value);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateTagsMessage {
pub resource_name: String,
pub tags: Vec<Tag>,
}
struct CreateTagsMessageSerializer;
impl CreateTagsMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CreateTagsMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(&format!("{}{}", prefix, "ResourceName"), &obj.resource_name);
TagListSerializer::serialize(params, &format!("{}{}", prefix, "Tag"), &obj.tags);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateUsageLimitMessage {
pub amount: i64,
pub breach_action: Option<String>,
pub cluster_identifier: String,
pub feature_type: String,
pub limit_type: String,
pub period: Option<String>,
pub tags: Option<Vec<Tag>>,
}
struct CreateUsageLimitMessageSerializer;
impl CreateUsageLimitMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CreateUsageLimitMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(&format!("{}{}", prefix, "Amount"), &obj.amount);
if let Some(ref field_value) = obj.breach_action {
params.put(&format!("{}{}", prefix, "BreachAction"), &field_value);
}
params.put(
&format!("{}{}", prefix, "ClusterIdentifier"),
&obj.cluster_identifier,
);
params.put(&format!("{}{}", prefix, "FeatureType"), &obj.feature_type);
params.put(&format!("{}{}", prefix, "LimitType"), &obj.limit_type);
if let Some(ref field_value) = obj.period {
params.put(&format!("{}{}", prefix, "Period"), &field_value);
}
if let Some(ref field_value) = obj.tags {
TagListSerializer::serialize(params, &format!("{}{}", prefix, "Tag"), field_value);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct CustomerStorageMessage {
pub total_backup_size_in_mega_bytes: Option<f64>,
pub total_provisioned_storage_in_mega_bytes: Option<f64>,
}
#[allow(dead_code)]
struct CustomerStorageMessageDeserializer;
impl CustomerStorageMessageDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CustomerStorageMessage, XmlParseError> {
deserialize_elements::<_, CustomerStorageMessage, _>(tag_name, stack, |name, stack, obj| {
match name {
"TotalBackupSizeInMegaBytes" => {
obj.total_backup_size_in_mega_bytes = Some(DoubleDeserializer::deserialize(
"TotalBackupSizeInMegaBytes",
stack,
)?);
}
"TotalProvisionedStorageInMegaBytes" => {
obj.total_provisioned_storage_in_mega_bytes =
Some(DoubleDeserializer::deserialize(
"TotalProvisionedStorageInMegaBytes",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct DataTransferProgress {
pub current_rate_in_mega_bytes_per_second: Option<f64>,
pub data_transferred_in_mega_bytes: Option<i64>,
pub elapsed_time_in_seconds: Option<i64>,
pub estimated_time_to_completion_in_seconds: Option<i64>,
pub status: Option<String>,
pub total_data_in_mega_bytes: Option<i64>,
}
#[allow(dead_code)]
struct DataTransferProgressDeserializer;
impl DataTransferProgressDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DataTransferProgress, XmlParseError> {
deserialize_elements::<_, DataTransferProgress, _>(tag_name, stack, |name, stack, obj| {
match name {
"CurrentRateInMegaBytesPerSecond" => {
obj.current_rate_in_mega_bytes_per_second =
Some(DoubleOptionalDeserializer::deserialize(
"CurrentRateInMegaBytesPerSecond",
stack,
)?);
}
"DataTransferredInMegaBytes" => {
obj.data_transferred_in_mega_bytes = Some(LongDeserializer::deserialize(
"DataTransferredInMegaBytes",
stack,
)?);
}
"ElapsedTimeInSeconds" => {
obj.elapsed_time_in_seconds = Some(LongOptionalDeserializer::deserialize(
"ElapsedTimeInSeconds",
stack,
)?);
}
"EstimatedTimeToCompletionInSeconds" => {
obj.estimated_time_to_completion_in_seconds =
Some(LongOptionalDeserializer::deserialize(
"EstimatedTimeToCompletionInSeconds",
stack,
)?);
}
"Status" => {
obj.status = Some(StringDeserializer::deserialize("Status", stack)?);
}
"TotalDataInMegaBytes" => {
obj.total_data_in_mega_bytes = Some(LongDeserializer::deserialize(
"TotalDataInMegaBytes",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct DbGroupListSerializer;
impl DbGroupListSerializer {
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 DefaultClusterParameters {
pub marker: Option<String>,
pub parameter_group_family: Option<String>,
pub parameters: Option<Vec<Parameter>>,
}
#[allow(dead_code)]
struct DefaultClusterParametersDeserializer;
impl DefaultClusterParametersDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DefaultClusterParameters, XmlParseError> {
deserialize_elements::<_, DefaultClusterParameters, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"Marker" => {
obj.marker = Some(StringDeserializer::deserialize("Marker", stack)?);
}
"ParameterGroupFamily" => {
obj.parameter_group_family = Some(StringDeserializer::deserialize(
"ParameterGroupFamily",
stack,
)?);
}
"Parameters" => {
obj.parameters.get_or_insert(vec![]).extend(
ParametersListDeserializer::deserialize("Parameters", stack)?,
);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct DeferredMaintenanceWindow {
pub defer_maintenance_end_time: Option<String>,
pub defer_maintenance_identifier: Option<String>,
pub defer_maintenance_start_time: Option<String>,
}
#[allow(dead_code)]
struct DeferredMaintenanceWindowDeserializer;
impl DeferredMaintenanceWindowDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DeferredMaintenanceWindow, XmlParseError> {
deserialize_elements::<_, DeferredMaintenanceWindow, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"DeferMaintenanceEndTime" => {
obj.defer_maintenance_end_time = Some(TStampDeserializer::deserialize(
"DeferMaintenanceEndTime",
stack,
)?);
}
"DeferMaintenanceIdentifier" => {
obj.defer_maintenance_identifier = Some(StringDeserializer::deserialize(
"DeferMaintenanceIdentifier",
stack,
)?);
}
"DeferMaintenanceStartTime" => {
obj.defer_maintenance_start_time = Some(TStampDeserializer::deserialize(
"DeferMaintenanceStartTime",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[allow(dead_code)]
struct DeferredMaintenanceWindowsListDeserializer;
impl DeferredMaintenanceWindowsListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<DeferredMaintenanceWindow>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "DeferredMaintenanceWindow" {
obj.push(DeferredMaintenanceWindowDeserializer::deserialize(
"DeferredMaintenanceWindow",
stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteClusterMessage {
pub cluster_identifier: String,
pub final_cluster_snapshot_identifier: Option<String>,
pub final_cluster_snapshot_retention_period: Option<i64>,
pub skip_final_cluster_snapshot: Option<bool>,
}
struct DeleteClusterMessageSerializer;
impl DeleteClusterMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DeleteClusterMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "ClusterIdentifier"),
&obj.cluster_identifier,
);
if let Some(ref field_value) = obj.final_cluster_snapshot_identifier {
params.put(
&format!("{}{}", prefix, "FinalClusterSnapshotIdentifier"),
&field_value,
);
}
if let Some(ref field_value) = obj.final_cluster_snapshot_retention_period {
params.put(
&format!("{}{}", prefix, "FinalClusterSnapshotRetentionPeriod"),
&field_value,
);
}
if let Some(ref field_value) = obj.skip_final_cluster_snapshot {
params.put(
&format!("{}{}", prefix, "SkipFinalClusterSnapshot"),
&field_value,
);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteClusterParameterGroupMessage {
pub parameter_group_name: String,
}
struct DeleteClusterParameterGroupMessageSerializer;
impl DeleteClusterParameterGroupMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DeleteClusterParameterGroupMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "ParameterGroupName"),
&obj.parameter_group_name,
);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct DeleteClusterResult {
pub cluster: Option<Cluster>,
}
#[allow(dead_code)]
struct DeleteClusterResultDeserializer;
impl DeleteClusterResultDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DeleteClusterResult, XmlParseError> {
deserialize_elements::<_, DeleteClusterResult, _>(tag_name, stack, |name, stack, obj| {
match name {
"Cluster" => {
obj.cluster = Some(ClusterDeserializer::deserialize("Cluster", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteClusterSecurityGroupMessage {
pub cluster_security_group_name: String,
}
struct DeleteClusterSecurityGroupMessageSerializer;
impl DeleteClusterSecurityGroupMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DeleteClusterSecurityGroupMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "ClusterSecurityGroupName"),
&obj.cluster_security_group_name,
);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteClusterSnapshotMessage {
pub snapshot_cluster_identifier: Option<String>,
pub snapshot_identifier: String,
}
struct DeleteClusterSnapshotMessageSerializer;
impl DeleteClusterSnapshotMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DeleteClusterSnapshotMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.snapshot_cluster_identifier {
params.put(
&format!("{}{}", prefix, "SnapshotClusterIdentifier"),
&field_value,
);
}
params.put(
&format!("{}{}", prefix, "SnapshotIdentifier"),
&obj.snapshot_identifier,
);
}
}
struct DeleteClusterSnapshotMessageListSerializer;
impl DeleteClusterSnapshotMessageListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<DeleteClusterSnapshotMessage>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.member.{}", name, index + 1);
DeleteClusterSnapshotMessageSerializer::serialize(params, &key, obj);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct DeleteClusterSnapshotResult {
pub snapshot: Option<Snapshot>,
}
#[allow(dead_code)]
struct DeleteClusterSnapshotResultDeserializer;
impl DeleteClusterSnapshotResultDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DeleteClusterSnapshotResult, XmlParseError> {
deserialize_elements::<_, DeleteClusterSnapshotResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"Snapshot" => {
obj.snapshot = Some(SnapshotDeserializer::deserialize("Snapshot", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteClusterSubnetGroupMessage {
pub cluster_subnet_group_name: String,
}
struct DeleteClusterSubnetGroupMessageSerializer;
impl DeleteClusterSubnetGroupMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DeleteClusterSubnetGroupMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "ClusterSubnetGroupName"),
&obj.cluster_subnet_group_name,
);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteEventSubscriptionMessage {
pub subscription_name: String,
}
struct DeleteEventSubscriptionMessageSerializer;
impl DeleteEventSubscriptionMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DeleteEventSubscriptionMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "SubscriptionName"),
&obj.subscription_name,
);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteHsmClientCertificateMessage {
pub hsm_client_certificate_identifier: String,
}
struct DeleteHsmClientCertificateMessageSerializer;
impl DeleteHsmClientCertificateMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DeleteHsmClientCertificateMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "HsmClientCertificateIdentifier"),
&obj.hsm_client_certificate_identifier,
);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteHsmConfigurationMessage {
pub hsm_configuration_identifier: String,
}
struct DeleteHsmConfigurationMessageSerializer;
impl DeleteHsmConfigurationMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DeleteHsmConfigurationMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "HsmConfigurationIdentifier"),
&obj.hsm_configuration_identifier,
);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteScheduledActionMessage {
pub scheduled_action_name: String,
}
struct DeleteScheduledActionMessageSerializer;
impl DeleteScheduledActionMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DeleteScheduledActionMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "ScheduledActionName"),
&obj.scheduled_action_name,
);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteSnapshotCopyGrantMessage {
pub snapshot_copy_grant_name: String,
}
struct DeleteSnapshotCopyGrantMessageSerializer;
impl DeleteSnapshotCopyGrantMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DeleteSnapshotCopyGrantMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "SnapshotCopyGrantName"),
&obj.snapshot_copy_grant_name,
);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteSnapshotScheduleMessage {
pub schedule_identifier: String,
}
struct DeleteSnapshotScheduleMessageSerializer;
impl DeleteSnapshotScheduleMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DeleteSnapshotScheduleMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "ScheduleIdentifier"),
&obj.schedule_identifier,
);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteTagsMessage {
pub resource_name: String,
pub tag_keys: Vec<String>,
}
struct DeleteTagsMessageSerializer;
impl DeleteTagsMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DeleteTagsMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(&format!("{}{}", prefix, "ResourceName"), &obj.resource_name);
TagKeyListSerializer::serialize(params, &format!("{}{}", prefix, "TagKey"), &obj.tag_keys);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteUsageLimitMessage {
pub usage_limit_id: String,
}
struct DeleteUsageLimitMessageSerializer;
impl DeleteUsageLimitMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DeleteUsageLimitMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "UsageLimitId"),
&obj.usage_limit_id,
);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeAccountAttributesMessage {
pub attribute_names: Option<Vec<String>>,
}
struct DescribeAccountAttributesMessageSerializer;
impl DescribeAccountAttributesMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeAccountAttributesMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.attribute_names {
AttributeNameListSerializer::serialize(
params,
&format!("{}{}", prefix, "AttributeName"),
field_value,
);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeClusterDbRevisionsMessage {
pub cluster_identifier: Option<String>,
pub marker: Option<String>,
pub max_records: Option<i64>,
}
struct DescribeClusterDbRevisionsMessageSerializer;
impl DescribeClusterDbRevisionsMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeClusterDbRevisionsMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.cluster_identifier {
params.put(&format!("{}{}", prefix, "ClusterIdentifier"), &field_value);
}
if let Some(ref field_value) = obj.marker {
params.put(&format!("{}{}", prefix, "Marker"), &field_value);
}
if let Some(ref field_value) = obj.max_records {
params.put(&format!("{}{}", prefix, "MaxRecords"), &field_value);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeClusterParameterGroupsMessage {
pub marker: Option<String>,
pub max_records: Option<i64>,
pub parameter_group_name: Option<String>,
pub tag_keys: Option<Vec<String>>,
pub tag_values: Option<Vec<String>>,
}
struct DescribeClusterParameterGroupsMessageSerializer;
impl DescribeClusterParameterGroupsMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeClusterParameterGroupsMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.marker {
params.put(&format!("{}{}", prefix, "Marker"), &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.parameter_group_name {
params.put(&format!("{}{}", prefix, "ParameterGroupName"), &field_value);
}
if let Some(ref field_value) = obj.tag_keys {
TagKeyListSerializer::serialize(
params,
&format!("{}{}", prefix, "TagKey"),
field_value,
);
}
if let Some(ref field_value) = obj.tag_values {
TagValueListSerializer::serialize(
params,
&format!("{}{}", prefix, "TagValue"),
field_value,
);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeClusterParametersMessage {
pub marker: Option<String>,
pub max_records: Option<i64>,
pub parameter_group_name: String,
pub source: Option<String>,
}
struct DescribeClusterParametersMessageSerializer;
impl DescribeClusterParametersMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeClusterParametersMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.marker {
params.put(&format!("{}{}", prefix, "Marker"), &field_value);
}
if let Some(ref field_value) = obj.max_records {
params.put(&format!("{}{}", prefix, "MaxRecords"), &field_value);
}
params.put(
&format!("{}{}", prefix, "ParameterGroupName"),
&obj.parameter_group_name,
);
if let Some(ref field_value) = obj.source {
params.put(&format!("{}{}", prefix, "Source"), &field_value);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeClusterSecurityGroupsMessage {
pub cluster_security_group_name: Option<String>,
pub marker: Option<String>,
pub max_records: Option<i64>,
pub tag_keys: Option<Vec<String>>,
pub tag_values: Option<Vec<String>>,
}
struct DescribeClusterSecurityGroupsMessageSerializer;
impl DescribeClusterSecurityGroupsMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeClusterSecurityGroupsMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.cluster_security_group_name {
params.put(
&format!("{}{}", prefix, "ClusterSecurityGroupName"),
&field_value,
);
}
if let Some(ref field_value) = obj.marker {
params.put(&format!("{}{}", prefix, "Marker"), &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.tag_keys {
TagKeyListSerializer::serialize(
params,
&format!("{}{}", prefix, "TagKey"),
field_value,
);
}
if let Some(ref field_value) = obj.tag_values {
TagValueListSerializer::serialize(
params,
&format!("{}{}", prefix, "TagValue"),
field_value,
);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeClusterSnapshotsMessage {
pub cluster_exists: Option<bool>,
pub cluster_identifier: Option<String>,
pub end_time: Option<String>,
pub marker: Option<String>,
pub max_records: Option<i64>,
pub owner_account: Option<String>,
pub snapshot_identifier: Option<String>,
pub snapshot_type: Option<String>,
pub sorting_entities: Option<Vec<SnapshotSortingEntity>>,
pub start_time: Option<String>,
pub tag_keys: Option<Vec<String>>,
pub tag_values: Option<Vec<String>>,
}
struct DescribeClusterSnapshotsMessageSerializer;
impl DescribeClusterSnapshotsMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeClusterSnapshotsMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.cluster_exists {
params.put(&format!("{}{}", prefix, "ClusterExists"), &field_value);
}
if let Some(ref field_value) = obj.cluster_identifier {
params.put(&format!("{}{}", prefix, "ClusterIdentifier"), &field_value);
}
if let Some(ref field_value) = obj.end_time {
params.put(&format!("{}{}", prefix, "EndTime"), &field_value);
}
if let Some(ref field_value) = obj.marker {
params.put(&format!("{}{}", prefix, "Marker"), &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.owner_account {
params.put(&format!("{}{}", prefix, "OwnerAccount"), &field_value);
}
if let Some(ref field_value) = obj.snapshot_identifier {
params.put(&format!("{}{}", prefix, "SnapshotIdentifier"), &field_value);
}
if let Some(ref field_value) = obj.snapshot_type {
params.put(&format!("{}{}", prefix, "SnapshotType"), &field_value);
}
if let Some(ref field_value) = obj.sorting_entities {
SnapshotSortingEntityListSerializer::serialize(
params,
&format!("{}{}", prefix, "SnapshotSortingEntity"),
field_value,
);
}
if let Some(ref field_value) = obj.start_time {
params.put(&format!("{}{}", prefix, "StartTime"), &field_value);
}
if let Some(ref field_value) = obj.tag_keys {
TagKeyListSerializer::serialize(
params,
&format!("{}{}", prefix, "TagKey"),
field_value,
);
}
if let Some(ref field_value) = obj.tag_values {
TagValueListSerializer::serialize(
params,
&format!("{}{}", prefix, "TagValue"),
field_value,
);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeClusterSubnetGroupsMessage {
pub cluster_subnet_group_name: Option<String>,
pub marker: Option<String>,
pub max_records: Option<i64>,
pub tag_keys: Option<Vec<String>>,
pub tag_values: Option<Vec<String>>,
}
struct DescribeClusterSubnetGroupsMessageSerializer;
impl DescribeClusterSubnetGroupsMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeClusterSubnetGroupsMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.cluster_subnet_group_name {
params.put(
&format!("{}{}", prefix, "ClusterSubnetGroupName"),
&field_value,
);
}
if let Some(ref field_value) = obj.marker {
params.put(&format!("{}{}", prefix, "Marker"), &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.tag_keys {
TagKeyListSerializer::serialize(
params,
&format!("{}{}", prefix, "TagKey"),
field_value,
);
}
if let Some(ref field_value) = obj.tag_values {
TagValueListSerializer::serialize(
params,
&format!("{}{}", prefix, "TagValue"),
field_value,
);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeClusterTracksMessage {
pub maintenance_track_name: Option<String>,
pub marker: Option<String>,
pub max_records: Option<i64>,
}
struct DescribeClusterTracksMessageSerializer;
impl DescribeClusterTracksMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeClusterTracksMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.maintenance_track_name {
params.put(
&format!("{}{}", prefix, "MaintenanceTrackName"),
&field_value,
);
}
if let Some(ref field_value) = obj.marker {
params.put(&format!("{}{}", prefix, "Marker"), &field_value);
}
if let Some(ref field_value) = obj.max_records {
params.put(&format!("{}{}", prefix, "MaxRecords"), &field_value);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeClusterVersionsMessage {
pub cluster_parameter_group_family: Option<String>,
pub cluster_version: Option<String>,
pub marker: Option<String>,
pub max_records: Option<i64>,
}
struct DescribeClusterVersionsMessageSerializer;
impl DescribeClusterVersionsMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeClusterVersionsMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.cluster_parameter_group_family {
params.put(
&format!("{}{}", prefix, "ClusterParameterGroupFamily"),
&field_value,
);
}
if let Some(ref field_value) = obj.cluster_version {
params.put(&format!("{}{}", prefix, "ClusterVersion"), &field_value);
}
if let Some(ref field_value) = obj.marker {
params.put(&format!("{}{}", prefix, "Marker"), &field_value);
}
if let Some(ref field_value) = obj.max_records {
params.put(&format!("{}{}", prefix, "MaxRecords"), &field_value);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeClustersMessage {
pub cluster_identifier: Option<String>,
pub marker: Option<String>,
pub max_records: Option<i64>,
pub tag_keys: Option<Vec<String>>,
pub tag_values: Option<Vec<String>>,
}
struct DescribeClustersMessageSerializer;
impl DescribeClustersMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeClustersMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.cluster_identifier {
params.put(&format!("{}{}", prefix, "ClusterIdentifier"), &field_value);
}
if let Some(ref field_value) = obj.marker {
params.put(&format!("{}{}", prefix, "Marker"), &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.tag_keys {
TagKeyListSerializer::serialize(
params,
&format!("{}{}", prefix, "TagKey"),
field_value,
);
}
if let Some(ref field_value) = obj.tag_values {
TagValueListSerializer::serialize(
params,
&format!("{}{}", prefix, "TagValue"),
field_value,
);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeDefaultClusterParametersMessage {
pub marker: Option<String>,
pub max_records: Option<i64>,
pub parameter_group_family: String,
}
struct DescribeDefaultClusterParametersMessageSerializer;
impl DescribeDefaultClusterParametersMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeDefaultClusterParametersMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.marker {
params.put(&format!("{}{}", prefix, "Marker"), &field_value);
}
if let Some(ref field_value) = obj.max_records {
params.put(&format!("{}{}", prefix, "MaxRecords"), &field_value);
}
params.put(
&format!("{}{}", prefix, "ParameterGroupFamily"),
&obj.parameter_group_family,
);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct DescribeDefaultClusterParametersResult {
pub default_cluster_parameters: Option<DefaultClusterParameters>,
}
#[allow(dead_code)]
struct DescribeDefaultClusterParametersResultDeserializer;
impl DescribeDefaultClusterParametersResultDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeDefaultClusterParametersResult, XmlParseError> {
deserialize_elements::<_, DescribeDefaultClusterParametersResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"DefaultClusterParameters" => {
obj.default_cluster_parameters =
Some(DefaultClusterParametersDeserializer::deserialize(
"DefaultClusterParameters",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeEventCategoriesMessage {
pub source_type: Option<String>,
}
struct DescribeEventCategoriesMessageSerializer;
impl DescribeEventCategoriesMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeEventCategoriesMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.source_type {
params.put(&format!("{}{}", prefix, "SourceType"), &field_value);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeEventSubscriptionsMessage {
pub marker: Option<String>,
pub max_records: Option<i64>,
pub subscription_name: Option<String>,
pub tag_keys: Option<Vec<String>>,
pub tag_values: Option<Vec<String>>,
}
struct DescribeEventSubscriptionsMessageSerializer;
impl DescribeEventSubscriptionsMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeEventSubscriptionsMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.marker {
params.put(&format!("{}{}", prefix, "Marker"), &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.subscription_name {
params.put(&format!("{}{}", prefix, "SubscriptionName"), &field_value);
}
if let Some(ref field_value) = obj.tag_keys {
TagKeyListSerializer::serialize(
params,
&format!("{}{}", prefix, "TagKey"),
field_value,
);
}
if let Some(ref field_value) = obj.tag_values {
TagValueListSerializer::serialize(
params,
&format!("{}{}", prefix, "TagValue"),
field_value,
);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeEventsMessage {
pub duration: Option<i64>,
pub end_time: Option<String>,
pub marker: Option<String>,
pub max_records: Option<i64>,
pub source_identifier: Option<String>,
pub source_type: Option<String>,
pub start_time: Option<String>,
}
struct DescribeEventsMessageSerializer;
impl DescribeEventsMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeEventsMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.duration {
params.put(&format!("{}{}", prefix, "Duration"), &field_value);
}
if let Some(ref field_value) = obj.end_time {
params.put(&format!("{}{}", prefix, "EndTime"), &field_value);
}
if let Some(ref field_value) = obj.marker {
params.put(&format!("{}{}", prefix, "Marker"), &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.source_identifier {
params.put(&format!("{}{}", prefix, "SourceIdentifier"), &field_value);
}
if let Some(ref field_value) = obj.source_type {
params.put(&format!("{}{}", prefix, "SourceType"), &field_value);
}
if let Some(ref field_value) = obj.start_time {
params.put(&format!("{}{}", prefix, "StartTime"), &field_value);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeHsmClientCertificatesMessage {
pub hsm_client_certificate_identifier: Option<String>,
pub marker: Option<String>,
pub max_records: Option<i64>,
pub tag_keys: Option<Vec<String>>,
pub tag_values: Option<Vec<String>>,
}
struct DescribeHsmClientCertificatesMessageSerializer;
impl DescribeHsmClientCertificatesMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeHsmClientCertificatesMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.hsm_client_certificate_identifier {
params.put(
&format!("{}{}", prefix, "HsmClientCertificateIdentifier"),
&field_value,
);
}
if let Some(ref field_value) = obj.marker {
params.put(&format!("{}{}", prefix, "Marker"), &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.tag_keys {
TagKeyListSerializer::serialize(
params,
&format!("{}{}", prefix, "TagKey"),
field_value,
);
}
if let Some(ref field_value) = obj.tag_values {
TagValueListSerializer::serialize(
params,
&format!("{}{}", prefix, "TagValue"),
field_value,
);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeHsmConfigurationsMessage {
pub hsm_configuration_identifier: Option<String>,
pub marker: Option<String>,
pub max_records: Option<i64>,
pub tag_keys: Option<Vec<String>>,
pub tag_values: Option<Vec<String>>,
}
struct DescribeHsmConfigurationsMessageSerializer;
impl DescribeHsmConfigurationsMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeHsmConfigurationsMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.hsm_configuration_identifier {
params.put(
&format!("{}{}", prefix, "HsmConfigurationIdentifier"),
&field_value,
);
}
if let Some(ref field_value) = obj.marker {
params.put(&format!("{}{}", prefix, "Marker"), &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.tag_keys {
TagKeyListSerializer::serialize(
params,
&format!("{}{}", prefix, "TagKey"),
field_value,
);
}
if let Some(ref field_value) = obj.tag_values {
TagValueListSerializer::serialize(
params,
&format!("{}{}", prefix, "TagValue"),
field_value,
);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeLoggingStatusMessage {
pub cluster_identifier: String,
}
struct DescribeLoggingStatusMessageSerializer;
impl DescribeLoggingStatusMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeLoggingStatusMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "ClusterIdentifier"),
&obj.cluster_identifier,
);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeNodeConfigurationOptionsMessage {
pub action_type: String,
pub cluster_identifier: Option<String>,
pub filters: Option<Vec<NodeConfigurationOptionsFilter>>,
pub marker: Option<String>,
pub max_records: Option<i64>,
pub owner_account: Option<String>,
pub snapshot_identifier: Option<String>,
}
struct DescribeNodeConfigurationOptionsMessageSerializer;
impl DescribeNodeConfigurationOptionsMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeNodeConfigurationOptionsMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(&format!("{}{}", prefix, "ActionType"), &obj.action_type);
if let Some(ref field_value) = obj.cluster_identifier {
params.put(&format!("{}{}", prefix, "ClusterIdentifier"), &field_value);
}
if let Some(ref field_value) = obj.filters {
NodeConfigurationOptionsFilterListSerializer::serialize(
params,
&format!("{}{}", prefix, "NodeConfigurationOptionsFilter"),
field_value,
);
}
if let Some(ref field_value) = obj.marker {
params.put(&format!("{}{}", prefix, "Marker"), &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.owner_account {
params.put(&format!("{}{}", prefix, "OwnerAccount"), &field_value);
}
if let Some(ref field_value) = obj.snapshot_identifier {
params.put(&format!("{}{}", prefix, "SnapshotIdentifier"), &field_value);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeOrderableClusterOptionsMessage {
pub cluster_version: Option<String>,
pub marker: Option<String>,
pub max_records: Option<i64>,
pub node_type: Option<String>,
}
struct DescribeOrderableClusterOptionsMessageSerializer;
impl DescribeOrderableClusterOptionsMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeOrderableClusterOptionsMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.cluster_version {
params.put(&format!("{}{}", prefix, "ClusterVersion"), &field_value);
}
if let Some(ref field_value) = obj.marker {
params.put(&format!("{}{}", prefix, "Marker"), &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.node_type {
params.put(&format!("{}{}", prefix, "NodeType"), &field_value);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeReservedNodeOfferingsMessage {
pub marker: Option<String>,
pub max_records: Option<i64>,
pub reserved_node_offering_id: Option<String>,
}
struct DescribeReservedNodeOfferingsMessageSerializer;
impl DescribeReservedNodeOfferingsMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeReservedNodeOfferingsMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.marker {
params.put(&format!("{}{}", prefix, "Marker"), &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.reserved_node_offering_id {
params.put(
&format!("{}{}", prefix, "ReservedNodeOfferingId"),
&field_value,
);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeReservedNodesMessage {
pub marker: Option<String>,
pub max_records: Option<i64>,
pub reserved_node_id: Option<String>,
}
struct DescribeReservedNodesMessageSerializer;
impl DescribeReservedNodesMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeReservedNodesMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.marker {
params.put(&format!("{}{}", prefix, "Marker"), &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.reserved_node_id {
params.put(&format!("{}{}", prefix, "ReservedNodeId"), &field_value);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeResizeMessage {
pub cluster_identifier: String,
}
struct DescribeResizeMessageSerializer;
impl DescribeResizeMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeResizeMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "ClusterIdentifier"),
&obj.cluster_identifier,
);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeScheduledActionsMessage {
pub active: Option<bool>,
pub end_time: Option<String>,
pub filters: Option<Vec<ScheduledActionFilter>>,
pub marker: Option<String>,
pub max_records: Option<i64>,
pub scheduled_action_name: Option<String>,
pub start_time: Option<String>,
pub target_action_type: Option<String>,
}
struct DescribeScheduledActionsMessageSerializer;
impl DescribeScheduledActionsMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeScheduledActionsMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.active {
params.put(&format!("{}{}", prefix, "Active"), &field_value);
}
if let Some(ref field_value) = obj.end_time {
params.put(&format!("{}{}", prefix, "EndTime"), &field_value);
}
if let Some(ref field_value) = obj.filters {
ScheduledActionFilterListSerializer::serialize(
params,
&format!("{}{}", prefix, "ScheduledActionFilter"),
field_value,
);
}
if let Some(ref field_value) = obj.marker {
params.put(&format!("{}{}", prefix, "Marker"), &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.scheduled_action_name {
params.put(
&format!("{}{}", prefix, "ScheduledActionName"),
&field_value,
);
}
if let Some(ref field_value) = obj.start_time {
params.put(&format!("{}{}", prefix, "StartTime"), &field_value);
}
if let Some(ref field_value) = obj.target_action_type {
params.put(&format!("{}{}", prefix, "TargetActionType"), &field_value);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeSnapshotCopyGrantsMessage {
pub marker: Option<String>,
pub max_records: Option<i64>,
pub snapshot_copy_grant_name: Option<String>,
pub tag_keys: Option<Vec<String>>,
pub tag_values: Option<Vec<String>>,
}
struct DescribeSnapshotCopyGrantsMessageSerializer;
impl DescribeSnapshotCopyGrantsMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeSnapshotCopyGrantsMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.marker {
params.put(&format!("{}{}", prefix, "Marker"), &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.snapshot_copy_grant_name {
params.put(
&format!("{}{}", prefix, "SnapshotCopyGrantName"),
&field_value,
);
}
if let Some(ref field_value) = obj.tag_keys {
TagKeyListSerializer::serialize(
params,
&format!("{}{}", prefix, "TagKey"),
field_value,
);
}
if let Some(ref field_value) = obj.tag_values {
TagValueListSerializer::serialize(
params,
&format!("{}{}", prefix, "TagValue"),
field_value,
);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeSnapshotSchedulesMessage {
pub cluster_identifier: Option<String>,
pub marker: Option<String>,
pub max_records: Option<i64>,
pub schedule_identifier: Option<String>,
pub tag_keys: Option<Vec<String>>,
pub tag_values: Option<Vec<String>>,
}
struct DescribeSnapshotSchedulesMessageSerializer;
impl DescribeSnapshotSchedulesMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeSnapshotSchedulesMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.cluster_identifier {
params.put(&format!("{}{}", prefix, "ClusterIdentifier"), &field_value);
}
if let Some(ref field_value) = obj.marker {
params.put(&format!("{}{}", prefix, "Marker"), &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.schedule_identifier {
params.put(&format!("{}{}", prefix, "ScheduleIdentifier"), &field_value);
}
if let Some(ref field_value) = obj.tag_keys {
TagKeyListSerializer::serialize(
params,
&format!("{}{}", prefix, "TagKey"),
field_value,
);
}
if let Some(ref field_value) = obj.tag_values {
TagValueListSerializer::serialize(
params,
&format!("{}{}", prefix, "TagValue"),
field_value,
);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct DescribeSnapshotSchedulesOutputMessage {
pub marker: Option<String>,
pub snapshot_schedules: Option<Vec<SnapshotSchedule>>,
}
#[allow(dead_code)]
struct DescribeSnapshotSchedulesOutputMessageDeserializer;
impl DescribeSnapshotSchedulesOutputMessageDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeSnapshotSchedulesOutputMessage, XmlParseError> {
deserialize_elements::<_, DescribeSnapshotSchedulesOutputMessage, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"Marker" => {
obj.marker = Some(StringDeserializer::deserialize("Marker", stack)?);
}
"SnapshotSchedules" => {
obj.snapshot_schedules.get_or_insert(vec![]).extend(
SnapshotScheduleListDeserializer::deserialize(
"SnapshotSchedules",
stack,
)?,
);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeTableRestoreStatusMessage {
pub cluster_identifier: Option<String>,
pub marker: Option<String>,
pub max_records: Option<i64>,
pub table_restore_request_id: Option<String>,
}
struct DescribeTableRestoreStatusMessageSerializer;
impl DescribeTableRestoreStatusMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeTableRestoreStatusMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.cluster_identifier {
params.put(&format!("{}{}", prefix, "ClusterIdentifier"), &field_value);
}
if let Some(ref field_value) = obj.marker {
params.put(&format!("{}{}", prefix, "Marker"), &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.table_restore_request_id {
params.put(
&format!("{}{}", prefix, "TableRestoreRequestId"),
&field_value,
);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeTagsMessage {
pub marker: Option<String>,
pub max_records: Option<i64>,
pub resource_name: Option<String>,
pub resource_type: Option<String>,
pub tag_keys: Option<Vec<String>>,
pub tag_values: Option<Vec<String>>,
}
struct DescribeTagsMessageSerializer;
impl DescribeTagsMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeTagsMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.marker {
params.put(&format!("{}{}", prefix, "Marker"), &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.resource_name {
params.put(&format!("{}{}", prefix, "ResourceName"), &field_value);
}
if let Some(ref field_value) = obj.resource_type {
params.put(&format!("{}{}", prefix, "ResourceType"), &field_value);
}
if let Some(ref field_value) = obj.tag_keys {
TagKeyListSerializer::serialize(
params,
&format!("{}{}", prefix, "TagKey"),
field_value,
);
}
if let Some(ref field_value) = obj.tag_values {
TagValueListSerializer::serialize(
params,
&format!("{}{}", prefix, "TagValue"),
field_value,
);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeUsageLimitsMessage {
pub cluster_identifier: Option<String>,
pub feature_type: Option<String>,
pub marker: Option<String>,
pub max_records: Option<i64>,
pub tag_keys: Option<Vec<String>>,
pub tag_values: Option<Vec<String>>,
pub usage_limit_id: Option<String>,
}
struct DescribeUsageLimitsMessageSerializer;
impl DescribeUsageLimitsMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeUsageLimitsMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.cluster_identifier {
params.put(&format!("{}{}", prefix, "ClusterIdentifier"), &field_value);
}
if let Some(ref field_value) = obj.feature_type {
params.put(&format!("{}{}", prefix, "FeatureType"), &field_value);
}
if let Some(ref field_value) = obj.marker {
params.put(&format!("{}{}", prefix, "Marker"), &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.tag_keys {
TagKeyListSerializer::serialize(
params,
&format!("{}{}", prefix, "TagKey"),
field_value,
);
}
if let Some(ref field_value) = obj.tag_values {
TagValueListSerializer::serialize(
params,
&format!("{}{}", prefix, "TagValue"),
field_value,
);
}
if let Some(ref field_value) = obj.usage_limit_id {
params.put(&format!("{}{}", prefix, "UsageLimitId"), &field_value);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DisableLoggingMessage {
pub cluster_identifier: String,
}
struct DisableLoggingMessageSerializer;
impl DisableLoggingMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DisableLoggingMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "ClusterIdentifier"),
&obj.cluster_identifier,
);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DisableSnapshotCopyMessage {
pub cluster_identifier: String,
}
struct DisableSnapshotCopyMessageSerializer;
impl DisableSnapshotCopyMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DisableSnapshotCopyMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "ClusterIdentifier"),
&obj.cluster_identifier,
);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct DisableSnapshotCopyResult {
pub cluster: Option<Cluster>,
}
#[allow(dead_code)]
struct DisableSnapshotCopyResultDeserializer;
impl DisableSnapshotCopyResultDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DisableSnapshotCopyResult, XmlParseError> {
deserialize_elements::<_, DisableSnapshotCopyResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"Cluster" => {
obj.cluster = Some(ClusterDeserializer::deserialize("Cluster", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[allow(dead_code)]
struct DoubleDeserializer;
impl DoubleDeserializer {
#[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 DoubleOptionalDeserializer;
impl DoubleOptionalDeserializer {
#[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()))
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct EC2SecurityGroup {
pub ec2_security_group_name: Option<String>,
pub ec2_security_group_owner_id: Option<String>,
pub status: Option<String>,
pub tags: Option<Vec<Tag>>,
}
#[allow(dead_code)]
struct EC2SecurityGroupDeserializer;
impl EC2SecurityGroupDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<EC2SecurityGroup, XmlParseError> {
deserialize_elements::<_, EC2SecurityGroup, _>(tag_name, stack, |name, stack, obj| {
match name {
"EC2SecurityGroupName" => {
obj.ec2_security_group_name = Some(StringDeserializer::deserialize(
"EC2SecurityGroupName",
stack,
)?);
}
"EC2SecurityGroupOwnerId" => {
obj.ec2_security_group_owner_id = Some(StringDeserializer::deserialize(
"EC2SecurityGroupOwnerId",
stack,
)?);
}
"Status" => {
obj.status = Some(StringDeserializer::deserialize("Status", stack)?);
}
"Tags" => {
obj.tags
.get_or_insert(vec![])
.extend(TagListDeserializer::deserialize("Tags", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[allow(dead_code)]
struct EC2SecurityGroupListDeserializer;
impl EC2SecurityGroupListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<EC2SecurityGroup>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "EC2SecurityGroup" {
obj.push(EC2SecurityGroupDeserializer::deserialize(
"EC2SecurityGroup",
stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct ElasticIpStatus {
pub elastic_ip: Option<String>,
pub status: Option<String>,
}
#[allow(dead_code)]
struct ElasticIpStatusDeserializer;
impl ElasticIpStatusDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ElasticIpStatus, XmlParseError> {
deserialize_elements::<_, ElasticIpStatus, _>(tag_name, stack, |name, stack, obj| {
match name {
"ElasticIp" => {
obj.elastic_ip = Some(StringDeserializer::deserialize("ElasticIp", stack)?);
}
"Status" => {
obj.status = Some(StringDeserializer::deserialize("Status", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[allow(dead_code)]
struct EligibleTracksToUpdateListDeserializer;
impl EligibleTracksToUpdateListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<UpdateTarget>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "UpdateTarget" {
obj.push(UpdateTargetDeserializer::deserialize(
"UpdateTarget",
stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct EnableLoggingMessage {
pub bucket_name: String,
pub cluster_identifier: String,
pub s3_key_prefix: Option<String>,
}
struct EnableLoggingMessageSerializer;
impl EnableLoggingMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &EnableLoggingMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(&format!("{}{}", prefix, "BucketName"), &obj.bucket_name);
params.put(
&format!("{}{}", prefix, "ClusterIdentifier"),
&obj.cluster_identifier,
);
if let Some(ref field_value) = obj.s3_key_prefix {
params.put(&format!("{}{}", prefix, "S3KeyPrefix"), &field_value);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct EnableSnapshotCopyMessage {
pub cluster_identifier: String,
pub destination_region: String,
pub manual_snapshot_retention_period: Option<i64>,
pub retention_period: Option<i64>,
pub snapshot_copy_grant_name: Option<String>,
}
struct EnableSnapshotCopyMessageSerializer;
impl EnableSnapshotCopyMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &EnableSnapshotCopyMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "ClusterIdentifier"),
&obj.cluster_identifier,
);
params.put(
&format!("{}{}", prefix, "DestinationRegion"),
&obj.destination_region,
);
if let Some(ref field_value) = obj.manual_snapshot_retention_period {
params.put(
&format!("{}{}", prefix, "ManualSnapshotRetentionPeriod"),
&field_value,
);
}
if let Some(ref field_value) = obj.retention_period {
params.put(&format!("{}{}", prefix, "RetentionPeriod"), &field_value);
}
if let Some(ref field_value) = obj.snapshot_copy_grant_name {
params.put(
&format!("{}{}", prefix, "SnapshotCopyGrantName"),
&field_value,
);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct EnableSnapshotCopyResult {
pub cluster: Option<Cluster>,
}
#[allow(dead_code)]
struct EnableSnapshotCopyResultDeserializer;
impl EnableSnapshotCopyResultDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<EnableSnapshotCopyResult, XmlParseError> {
deserialize_elements::<_, EnableSnapshotCopyResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"Cluster" => {
obj.cluster = Some(ClusterDeserializer::deserialize("Cluster", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct Endpoint {
pub address: Option<String>,
pub port: Option<i64>,
}
#[allow(dead_code)]
struct EndpointDeserializer;
impl EndpointDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Endpoint, XmlParseError> {
deserialize_elements::<_, Endpoint, _>(tag_name, stack, |name, stack, obj| {
match name {
"Address" => {
obj.address = Some(StringDeserializer::deserialize("Address", stack)?);
}
"Port" => {
obj.port = Some(IntegerDeserializer::deserialize("Port", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct Event {
pub date: Option<String>,
pub event_categories: Option<Vec<String>>,
pub event_id: Option<String>,
pub message: Option<String>,
pub severity: Option<String>,
pub source_identifier: Option<String>,
pub source_type: Option<String>,
}
#[allow(dead_code)]
struct EventDeserializer;
impl EventDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<Event, XmlParseError> {
deserialize_elements::<_, Event, _>(tag_name, stack, |name, stack, obj| {
match name {
"Date" => {
obj.date = Some(TStampDeserializer::deserialize("Date", stack)?);
}
"EventCategories" => {
obj.event_categories.get_or_insert(vec![]).extend(
EventCategoriesListDeserializer::deserialize("EventCategories", stack)?,
);
}
"EventId" => {
obj.event_id = Some(StringDeserializer::deserialize("EventId", stack)?);
}
"Message" => {
obj.message = Some(StringDeserializer::deserialize("Message", stack)?);
}
"Severity" => {
obj.severity = Some(StringDeserializer::deserialize("Severity", stack)?);
}
"SourceIdentifier" => {
obj.source_identifier =
Some(StringDeserializer::deserialize("SourceIdentifier", stack)?);
}
"SourceType" => {
obj.source_type =
Some(SourceTypeDeserializer::deserialize("SourceType", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[allow(dead_code)]
struct EventCategoriesListDeserializer;
impl EventCategoriesListDeserializer {
#[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 == "EventCategory" {
obj.push(StringDeserializer::deserialize("EventCategory", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct EventCategoriesListSerializer;
impl EventCategoriesListSerializer {
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 EventCategoriesMap {
pub events: Option<Vec<EventInfoMap>>,
pub source_type: Option<String>,
}
#[allow(dead_code)]
struct EventCategoriesMapDeserializer;
impl EventCategoriesMapDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<EventCategoriesMap, XmlParseError> {
deserialize_elements::<_, EventCategoriesMap, _>(tag_name, stack, |name, stack, obj| {
match name {
"Events" => {
obj.events
.get_or_insert(vec![])
.extend(EventInfoMapListDeserializer::deserialize("Events", stack)?);
}
"SourceType" => {
obj.source_type = Some(StringDeserializer::deserialize("SourceType", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[allow(dead_code)]
struct EventCategoriesMapListDeserializer;
impl EventCategoriesMapListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<EventCategoriesMap>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "EventCategoriesMap" {
obj.push(EventCategoriesMapDeserializer::deserialize(
"EventCategoriesMap",
stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct EventCategoriesMessage {
pub event_categories_map_list: Option<Vec<EventCategoriesMap>>,
}
#[allow(dead_code)]
struct EventCategoriesMessageDeserializer;
impl EventCategoriesMessageDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<EventCategoriesMessage, XmlParseError> {
deserialize_elements::<_, EventCategoriesMessage, _>(tag_name, stack, |name, stack, obj| {
match name {
"EventCategoriesMapList" => {
obj.event_categories_map_list.get_or_insert(vec![]).extend(
EventCategoriesMapListDeserializer::deserialize(
"EventCategoriesMapList",
stack,
)?,
);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct EventInfoMap {
pub event_categories: Option<Vec<String>>,
pub event_description: Option<String>,
pub event_id: Option<String>,
pub severity: Option<String>,
}
#[allow(dead_code)]
struct EventInfoMapDeserializer;
impl EventInfoMapDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<EventInfoMap, XmlParseError> {
deserialize_elements::<_, EventInfoMap, _>(tag_name, stack, |name, stack, obj| {
match name {
"EventCategories" => {
obj.event_categories.get_or_insert(vec![]).extend(
EventCategoriesListDeserializer::deserialize("EventCategories", stack)?,
);
}
"EventDescription" => {
obj.event_description =
Some(StringDeserializer::deserialize("EventDescription", stack)?);
}
"EventId" => {
obj.event_id = Some(StringDeserializer::deserialize("EventId", stack)?);
}
"Severity" => {
obj.severity = Some(StringDeserializer::deserialize("Severity", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[allow(dead_code)]
struct EventInfoMapListDeserializer;
impl EventInfoMapListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<EventInfoMap>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "EventInfoMap" {
obj.push(EventInfoMapDeserializer::deserialize(
"EventInfoMap",
stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[allow(dead_code)]
struct EventListDeserializer;
impl EventListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<Event>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "Event" {
obj.push(EventDeserializer::deserialize("Event", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct EventSubscription {
pub cust_subscription_id: Option<String>,
pub customer_aws_id: Option<String>,
pub enabled: Option<bool>,
pub event_categories_list: Option<Vec<String>>,
pub severity: Option<String>,
pub sns_topic_arn: Option<String>,
pub source_ids_list: Option<Vec<String>>,
pub source_type: Option<String>,
pub status: Option<String>,
pub subscription_creation_time: Option<String>,
pub tags: Option<Vec<Tag>>,
}
#[allow(dead_code)]
struct EventSubscriptionDeserializer;
impl EventSubscriptionDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<EventSubscription, XmlParseError> {
deserialize_elements::<_, EventSubscription, _>(tag_name, stack, |name, stack, obj| {
match name {
"CustSubscriptionId" => {
obj.cust_subscription_id = Some(StringDeserializer::deserialize(
"CustSubscriptionId",
stack,
)?);
}
"CustomerAwsId" => {
obj.customer_aws_id =
Some(StringDeserializer::deserialize("CustomerAwsId", stack)?);
}
"Enabled" => {
obj.enabled = Some(BooleanDeserializer::deserialize("Enabled", stack)?);
}
"EventCategoriesList" => {
obj.event_categories_list.get_or_insert(vec![]).extend(
EventCategoriesListDeserializer::deserialize("EventCategoriesList", stack)?,
);
}
"Severity" => {
obj.severity = Some(StringDeserializer::deserialize("Severity", stack)?);
}
"SnsTopicArn" => {
obj.sns_topic_arn =
Some(StringDeserializer::deserialize("SnsTopicArn", stack)?);
}
"SourceIdsList" => {
obj.source_ids_list.get_or_insert(vec![]).extend(
SourceIdsListDeserializer::deserialize("SourceIdsList", stack)?,
);
}
"SourceType" => {
obj.source_type = Some(StringDeserializer::deserialize("SourceType", stack)?);
}
"Status" => {
obj.status = Some(StringDeserializer::deserialize("Status", stack)?);
}
"SubscriptionCreationTime" => {
obj.subscription_creation_time = Some(TStampDeserializer::deserialize(
"SubscriptionCreationTime",
stack,
)?);
}
"Tags" => {
obj.tags
.get_or_insert(vec![])
.extend(TagListDeserializer::deserialize("Tags", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[allow(dead_code)]
struct EventSubscriptionsListDeserializer;
impl EventSubscriptionsListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<EventSubscription>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "EventSubscription" {
obj.push(EventSubscriptionDeserializer::deserialize(
"EventSubscription",
stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct EventSubscriptionsMessage {
pub event_subscriptions_list: Option<Vec<EventSubscription>>,
pub marker: Option<String>,
}
#[allow(dead_code)]
struct EventSubscriptionsMessageDeserializer;
impl EventSubscriptionsMessageDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<EventSubscriptionsMessage, XmlParseError> {
deserialize_elements::<_, EventSubscriptionsMessage, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"EventSubscriptionsList" => {
obj.event_subscriptions_list.get_or_insert(vec![]).extend(
EventSubscriptionsListDeserializer::deserialize(
"EventSubscriptionsList",
stack,
)?,
);
}
"Marker" => {
obj.marker = Some(StringDeserializer::deserialize("Marker", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct EventsMessage {
pub events: Option<Vec<Event>>,
pub marker: Option<String>,
}
#[allow(dead_code)]
struct EventsMessageDeserializer;
impl EventsMessageDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<EventsMessage, XmlParseError> {
deserialize_elements::<_, EventsMessage, _>(tag_name, stack, |name, stack, obj| {
match name {
"Events" => {
obj.events
.get_or_insert(vec![])
.extend(EventListDeserializer::deserialize("Events", stack)?);
}
"Marker" => {
obj.marker = Some(StringDeserializer::deserialize("Marker", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetClusterCredentialsMessage {
pub auto_create: Option<bool>,
pub cluster_identifier: String,
pub db_groups: Option<Vec<String>>,
pub db_name: Option<String>,
pub db_user: String,
pub duration_seconds: Option<i64>,
}
struct GetClusterCredentialsMessageSerializer;
impl GetClusterCredentialsMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &GetClusterCredentialsMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.auto_create {
params.put(&format!("{}{}", prefix, "AutoCreate"), &field_value);
}
params.put(
&format!("{}{}", prefix, "ClusterIdentifier"),
&obj.cluster_identifier,
);
if let Some(ref field_value) = obj.db_groups {
DbGroupListSerializer::serialize(
params,
&format!("{}{}", prefix, "DbGroup"),
field_value,
);
}
if let Some(ref field_value) = obj.db_name {
params.put(&format!("{}{}", prefix, "DbName"), &field_value);
}
params.put(&format!("{}{}", prefix, "DbUser"), &obj.db_user);
if let Some(ref field_value) = obj.duration_seconds {
params.put(&format!("{}{}", prefix, "DurationSeconds"), &field_value);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetReservedNodeExchangeOfferingsInputMessage {
pub marker: Option<String>,
pub max_records: Option<i64>,
pub reserved_node_id: String,
}
struct GetReservedNodeExchangeOfferingsInputMessageSerializer;
impl GetReservedNodeExchangeOfferingsInputMessageSerializer {
fn serialize(
params: &mut Params,
name: &str,
obj: &GetReservedNodeExchangeOfferingsInputMessage,
) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.marker {
params.put(&format!("{}{}", prefix, "Marker"), &field_value);
}
if let Some(ref field_value) = obj.max_records {
params.put(&format!("{}{}", prefix, "MaxRecords"), &field_value);
}
params.put(
&format!("{}{}", prefix, "ReservedNodeId"),
&obj.reserved_node_id,
);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct GetReservedNodeExchangeOfferingsOutputMessage {
pub marker: Option<String>,
pub reserved_node_offerings: Option<Vec<ReservedNodeOffering>>,
}
#[allow(dead_code)]
struct GetReservedNodeExchangeOfferingsOutputMessageDeserializer;
impl GetReservedNodeExchangeOfferingsOutputMessageDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<GetReservedNodeExchangeOfferingsOutputMessage, XmlParseError> {
deserialize_elements::<_, GetReservedNodeExchangeOfferingsOutputMessage, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"Marker" => {
obj.marker = Some(StringDeserializer::deserialize("Marker", stack)?);
}
"ReservedNodeOfferings" => {
obj.reserved_node_offerings.get_or_insert(vec![]).extend(
ReservedNodeOfferingListDeserializer::deserialize(
"ReservedNodeOfferings",
stack,
)?,
);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct HsmClientCertificate {
pub hsm_client_certificate_identifier: Option<String>,
pub hsm_client_certificate_public_key: Option<String>,
pub tags: Option<Vec<Tag>>,
}
#[allow(dead_code)]
struct HsmClientCertificateDeserializer;
impl HsmClientCertificateDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<HsmClientCertificate, XmlParseError> {
deserialize_elements::<_, HsmClientCertificate, _>(tag_name, stack, |name, stack, obj| {
match name {
"HsmClientCertificateIdentifier" => {
obj.hsm_client_certificate_identifier = Some(StringDeserializer::deserialize(
"HsmClientCertificateIdentifier",
stack,
)?);
}
"HsmClientCertificatePublicKey" => {
obj.hsm_client_certificate_public_key = Some(StringDeserializer::deserialize(
"HsmClientCertificatePublicKey",
stack,
)?);
}
"Tags" => {
obj.tags
.get_or_insert(vec![])
.extend(TagListDeserializer::deserialize("Tags", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[allow(dead_code)]
struct HsmClientCertificateListDeserializer;
impl HsmClientCertificateListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<HsmClientCertificate>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "HsmClientCertificate" {
obj.push(HsmClientCertificateDeserializer::deserialize(
"HsmClientCertificate",
stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct HsmClientCertificateMessage {
pub hsm_client_certificates: Option<Vec<HsmClientCertificate>>,
pub marker: Option<String>,
}
#[allow(dead_code)]
struct HsmClientCertificateMessageDeserializer;
impl HsmClientCertificateMessageDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<HsmClientCertificateMessage, XmlParseError> {
deserialize_elements::<_, HsmClientCertificateMessage, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"HsmClientCertificates" => {
obj.hsm_client_certificates.get_or_insert(vec![]).extend(
HsmClientCertificateListDeserializer::deserialize(
"HsmClientCertificates",
stack,
)?,
);
}
"Marker" => {
obj.marker = Some(StringDeserializer::deserialize("Marker", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct HsmConfiguration {
pub description: Option<String>,
pub hsm_configuration_identifier: Option<String>,
pub hsm_ip_address: Option<String>,
pub hsm_partition_name: Option<String>,
pub tags: Option<Vec<Tag>>,
}
#[allow(dead_code)]
struct HsmConfigurationDeserializer;
impl HsmConfigurationDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<HsmConfiguration, XmlParseError> {
deserialize_elements::<_, HsmConfiguration, _>(tag_name, stack, |name, stack, obj| {
match name {
"Description" => {
obj.description = Some(StringDeserializer::deserialize("Description", stack)?);
}
"HsmConfigurationIdentifier" => {
obj.hsm_configuration_identifier = Some(StringDeserializer::deserialize(
"HsmConfigurationIdentifier",
stack,
)?);
}
"HsmIpAddress" => {
obj.hsm_ip_address =
Some(StringDeserializer::deserialize("HsmIpAddress", stack)?);
}
"HsmPartitionName" => {
obj.hsm_partition_name =
Some(StringDeserializer::deserialize("HsmPartitionName", stack)?);
}
"Tags" => {
obj.tags
.get_or_insert(vec![])
.extend(TagListDeserializer::deserialize("Tags", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[allow(dead_code)]
struct HsmConfigurationListDeserializer;
impl HsmConfigurationListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<HsmConfiguration>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "HsmConfiguration" {
obj.push(HsmConfigurationDeserializer::deserialize(
"HsmConfiguration",
stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct HsmConfigurationMessage {
pub hsm_configurations: Option<Vec<HsmConfiguration>>,
pub marker: Option<String>,
}
#[allow(dead_code)]
struct HsmConfigurationMessageDeserializer;
impl HsmConfigurationMessageDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<HsmConfigurationMessage, XmlParseError> {
deserialize_elements::<_, HsmConfigurationMessage, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"HsmConfigurations" => {
obj.hsm_configurations.get_or_insert(vec![]).extend(
HsmConfigurationListDeserializer::deserialize(
"HsmConfigurations",
stack,
)?,
);
}
"Marker" => {
obj.marker = Some(StringDeserializer::deserialize("Marker", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct HsmStatus {
pub hsm_client_certificate_identifier: Option<String>,
pub hsm_configuration_identifier: Option<String>,
pub status: Option<String>,
}
#[allow(dead_code)]
struct HsmStatusDeserializer;
impl HsmStatusDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<HsmStatus, XmlParseError> {
deserialize_elements::<_, HsmStatus, _>(tag_name, stack, |name, stack, obj| {
match name {
"HsmClientCertificateIdentifier" => {
obj.hsm_client_certificate_identifier = Some(StringDeserializer::deserialize(
"HsmClientCertificateIdentifier",
stack,
)?);
}
"HsmConfigurationIdentifier" => {
obj.hsm_configuration_identifier = Some(StringDeserializer::deserialize(
"HsmConfigurationIdentifier",
stack,
)?);
}
"Status" => {
obj.status = Some(StringDeserializer::deserialize("Status", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct IPRange {
pub cidrip: Option<String>,
pub status: Option<String>,
pub tags: Option<Vec<Tag>>,
}
#[allow(dead_code)]
struct IPRangeDeserializer;
impl IPRangeDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<IPRange, XmlParseError> {
deserialize_elements::<_, IPRange, _>(tag_name, stack, |name, stack, obj| {
match name {
"CIDRIP" => {
obj.cidrip = Some(StringDeserializer::deserialize("CIDRIP", stack)?);
}
"Status" => {
obj.status = Some(StringDeserializer::deserialize("Status", stack)?);
}
"Tags" => {
obj.tags
.get_or_insert(vec![])
.extend(TagListDeserializer::deserialize("Tags", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[allow(dead_code)]
struct IPRangeListDeserializer;
impl IPRangeListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<IPRange>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "IPRange" {
obj.push(IPRangeDeserializer::deserialize("IPRange", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct IamRoleArnListSerializer;
impl IamRoleArnListSerializer {
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 ImportTablesCompletedDeserializer;
impl ImportTablesCompletedDeserializer {
#[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(StringDeserializer::deserialize("member", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[allow(dead_code)]
struct ImportTablesInProgressDeserializer;
impl ImportTablesInProgressDeserializer {
#[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(StringDeserializer::deserialize("member", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[allow(dead_code)]
struct ImportTablesNotStartedDeserializer;
impl ImportTablesNotStartedDeserializer {
#[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(StringDeserializer::deserialize("member", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[allow(dead_code)]
struct IntegerDeserializer;
impl IntegerDeserializer {
#[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 IntegerOptionalDeserializer;
impl IntegerOptionalDeserializer {
#[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 = "serialize_structs", derive(Serialize))]
pub struct LoggingStatus {
pub bucket_name: Option<String>,
pub last_failure_message: Option<String>,
pub last_failure_time: Option<String>,
pub last_successful_delivery_time: Option<String>,
pub logging_enabled: Option<bool>,
pub s3_key_prefix: Option<String>,
}
#[allow(dead_code)]
struct LoggingStatusDeserializer;
impl LoggingStatusDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<LoggingStatus, XmlParseError> {
deserialize_elements::<_, LoggingStatus, _>(tag_name, stack, |name, stack, obj| {
match name {
"BucketName" => {
obj.bucket_name = Some(StringDeserializer::deserialize("BucketName", stack)?);
}
"LastFailureMessage" => {
obj.last_failure_message = Some(StringDeserializer::deserialize(
"LastFailureMessage",
stack,
)?);
}
"LastFailureTime" => {
obj.last_failure_time =
Some(TStampDeserializer::deserialize("LastFailureTime", stack)?);
}
"LastSuccessfulDeliveryTime" => {
obj.last_successful_delivery_time = Some(TStampDeserializer::deserialize(
"LastSuccessfulDeliveryTime",
stack,
)?);
}
"LoggingEnabled" => {
obj.logging_enabled =
Some(BooleanDeserializer::deserialize("LoggingEnabled", stack)?);
}
"S3KeyPrefix" => {
obj.s3_key_prefix =
Some(StringDeserializer::deserialize("S3KeyPrefix", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[allow(dead_code)]
struct LongDeserializer;
impl LongDeserializer {
#[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 LongOptionalDeserializer;
impl LongOptionalDeserializer {
#[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 = "serialize_structs", derive(Serialize))]
pub struct MaintenanceTrack {
pub database_version: Option<String>,
pub maintenance_track_name: Option<String>,
pub update_targets: Option<Vec<UpdateTarget>>,
}
#[allow(dead_code)]
struct MaintenanceTrackDeserializer;
impl MaintenanceTrackDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<MaintenanceTrack, XmlParseError> {
deserialize_elements::<_, MaintenanceTrack, _>(tag_name, stack, |name, stack, obj| {
match name {
"DatabaseVersion" => {
obj.database_version =
Some(StringDeserializer::deserialize("DatabaseVersion", stack)?);
}
"MaintenanceTrackName" => {
obj.maintenance_track_name = Some(StringDeserializer::deserialize(
"MaintenanceTrackName",
stack,
)?);
}
"UpdateTargets" => {
obj.update_targets.get_or_insert(vec![]).extend(
EligibleTracksToUpdateListDeserializer::deserialize(
"UpdateTargets",
stack,
)?,
);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[allow(dead_code)]
struct ModeDeserializer;
impl ModeDeserializer {
#[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 ModifyClusterDbRevisionMessage {
pub cluster_identifier: String,
pub revision_target: String,
}
struct ModifyClusterDbRevisionMessageSerializer;
impl ModifyClusterDbRevisionMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ModifyClusterDbRevisionMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "ClusterIdentifier"),
&obj.cluster_identifier,
);
params.put(
&format!("{}{}", prefix, "RevisionTarget"),
&obj.revision_target,
);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct ModifyClusterDbRevisionResult {
pub cluster: Option<Cluster>,
}
#[allow(dead_code)]
struct ModifyClusterDbRevisionResultDeserializer;
impl ModifyClusterDbRevisionResultDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ModifyClusterDbRevisionResult, XmlParseError> {
deserialize_elements::<_, ModifyClusterDbRevisionResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"Cluster" => {
obj.cluster = Some(ClusterDeserializer::deserialize("Cluster", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ModifyClusterIamRolesMessage {
pub add_iam_roles: Option<Vec<String>>,
pub cluster_identifier: String,
pub remove_iam_roles: Option<Vec<String>>,
}
struct ModifyClusterIamRolesMessageSerializer;
impl ModifyClusterIamRolesMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ModifyClusterIamRolesMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.add_iam_roles {
IamRoleArnListSerializer::serialize(
params,
&format!("{}{}", prefix, "IamRoleArn"),
field_value,
);
}
params.put(
&format!("{}{}", prefix, "ClusterIdentifier"),
&obj.cluster_identifier,
);
if let Some(ref field_value) = obj.remove_iam_roles {
IamRoleArnListSerializer::serialize(
params,
&format!("{}{}", prefix, "IamRoleArn"),
field_value,
);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct ModifyClusterIamRolesResult {
pub cluster: Option<Cluster>,
}
#[allow(dead_code)]
struct ModifyClusterIamRolesResultDeserializer;
impl ModifyClusterIamRolesResultDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ModifyClusterIamRolesResult, XmlParseError> {
deserialize_elements::<_, ModifyClusterIamRolesResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"Cluster" => {
obj.cluster = Some(ClusterDeserializer::deserialize("Cluster", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ModifyClusterMaintenanceMessage {
pub cluster_identifier: String,
pub defer_maintenance: Option<bool>,
pub defer_maintenance_duration: Option<i64>,
pub defer_maintenance_end_time: Option<String>,
pub defer_maintenance_identifier: Option<String>,
pub defer_maintenance_start_time: Option<String>,
}
struct ModifyClusterMaintenanceMessageSerializer;
impl ModifyClusterMaintenanceMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ModifyClusterMaintenanceMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "ClusterIdentifier"),
&obj.cluster_identifier,
);
if let Some(ref field_value) = obj.defer_maintenance {
params.put(&format!("{}{}", prefix, "DeferMaintenance"), &field_value);
}
if let Some(ref field_value) = obj.defer_maintenance_duration {
params.put(
&format!("{}{}", prefix, "DeferMaintenanceDuration"),
&field_value,
);
}
if let Some(ref field_value) = obj.defer_maintenance_end_time {
params.put(
&format!("{}{}", prefix, "DeferMaintenanceEndTime"),
&field_value,
);
}
if let Some(ref field_value) = obj.defer_maintenance_identifier {
params.put(
&format!("{}{}", prefix, "DeferMaintenanceIdentifier"),
&field_value,
);
}
if let Some(ref field_value) = obj.defer_maintenance_start_time {
params.put(
&format!("{}{}", prefix, "DeferMaintenanceStartTime"),
&field_value,
);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct ModifyClusterMaintenanceResult {
pub cluster: Option<Cluster>,
}
#[allow(dead_code)]
struct ModifyClusterMaintenanceResultDeserializer;
impl ModifyClusterMaintenanceResultDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ModifyClusterMaintenanceResult, XmlParseError> {
deserialize_elements::<_, ModifyClusterMaintenanceResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"Cluster" => {
obj.cluster = Some(ClusterDeserializer::deserialize("Cluster", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ModifyClusterMessage {
pub allow_version_upgrade: Option<bool>,
pub automated_snapshot_retention_period: Option<i64>,
pub cluster_identifier: String,
pub cluster_parameter_group_name: Option<String>,
pub cluster_security_groups: Option<Vec<String>>,
pub cluster_type: Option<String>,
pub cluster_version: Option<String>,
pub elastic_ip: Option<String>,
pub encrypted: Option<bool>,
pub enhanced_vpc_routing: Option<bool>,
pub hsm_client_certificate_identifier: Option<String>,
pub hsm_configuration_identifier: Option<String>,
pub kms_key_id: Option<String>,
pub maintenance_track_name: Option<String>,
pub manual_snapshot_retention_period: Option<i64>,
pub master_user_password: Option<String>,
pub new_cluster_identifier: Option<String>,
pub node_type: Option<String>,
pub number_of_nodes: Option<i64>,
pub preferred_maintenance_window: Option<String>,
pub publicly_accessible: Option<bool>,
pub vpc_security_group_ids: Option<Vec<String>>,
}
struct ModifyClusterMessageSerializer;
impl ModifyClusterMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ModifyClusterMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.allow_version_upgrade {
params.put(
&format!("{}{}", prefix, "AllowVersionUpgrade"),
&field_value,
);
}
if let Some(ref field_value) = obj.automated_snapshot_retention_period {
params.put(
&format!("{}{}", prefix, "AutomatedSnapshotRetentionPeriod"),
&field_value,
);
}
params.put(
&format!("{}{}", prefix, "ClusterIdentifier"),
&obj.cluster_identifier,
);
if let Some(ref field_value) = obj.cluster_parameter_group_name {
params.put(
&format!("{}{}", prefix, "ClusterParameterGroupName"),
&field_value,
);
}
if let Some(ref field_value) = obj.cluster_security_groups {
ClusterSecurityGroupNameListSerializer::serialize(
params,
&format!("{}{}", prefix, "ClusterSecurityGroupName"),
field_value,
);
}
if let Some(ref field_value) = obj.cluster_type {
params.put(&format!("{}{}", prefix, "ClusterType"), &field_value);
}
if let Some(ref field_value) = obj.cluster_version {
params.put(&format!("{}{}", prefix, "ClusterVersion"), &field_value);
}
if let Some(ref field_value) = obj.elastic_ip {
params.put(&format!("{}{}", prefix, "ElasticIp"), &field_value);
}
if let Some(ref field_value) = obj.encrypted {
params.put(&format!("{}{}", prefix, "Encrypted"), &field_value);
}
if let Some(ref field_value) = obj.enhanced_vpc_routing {
params.put(&format!("{}{}", prefix, "EnhancedVpcRouting"), &field_value);
}
if let Some(ref field_value) = obj.hsm_client_certificate_identifier {
params.put(
&format!("{}{}", prefix, "HsmClientCertificateIdentifier"),
&field_value,
);
}
if let Some(ref field_value) = obj.hsm_configuration_identifier {
params.put(
&format!("{}{}", prefix, "HsmConfigurationIdentifier"),
&field_value,
);
}
if let Some(ref field_value) = obj.kms_key_id {
params.put(&format!("{}{}", prefix, "KmsKeyId"), &field_value);
}
if let Some(ref field_value) = obj.maintenance_track_name {
params.put(
&format!("{}{}", prefix, "MaintenanceTrackName"),
&field_value,
);
}
if let Some(ref field_value) = obj.manual_snapshot_retention_period {
params.put(
&format!("{}{}", prefix, "ManualSnapshotRetentionPeriod"),
&field_value,
);
}
if let Some(ref field_value) = obj.master_user_password {
params.put(&format!("{}{}", prefix, "MasterUserPassword"), &field_value);
}
if let Some(ref field_value) = obj.new_cluster_identifier {
params.put(
&format!("{}{}", prefix, "NewClusterIdentifier"),
&field_value,
);
}
if let Some(ref field_value) = obj.node_type {
params.put(&format!("{}{}", prefix, "NodeType"), &field_value);
}
if let Some(ref field_value) = obj.number_of_nodes {
params.put(&format!("{}{}", prefix, "NumberOfNodes"), &field_value);
}
if let Some(ref field_value) = obj.preferred_maintenance_window {
params.put(
&format!("{}{}", prefix, "PreferredMaintenanceWindow"),
&field_value,
);
}
if let Some(ref field_value) = obj.publicly_accessible {
params.put(&format!("{}{}", prefix, "PubliclyAccessible"), &field_value);
}
if let Some(ref field_value) = obj.vpc_security_group_ids {
VpcSecurityGroupIdListSerializer::serialize(
params,
&format!("{}{}", prefix, "VpcSecurityGroupId"),
field_value,
);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ModifyClusterParameterGroupMessage {
pub parameter_group_name: String,
pub parameters: Vec<Parameter>,
}
struct ModifyClusterParameterGroupMessageSerializer;
impl ModifyClusterParameterGroupMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ModifyClusterParameterGroupMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "ParameterGroupName"),
&obj.parameter_group_name,
);
ParametersListSerializer::serialize(
params,
&format!("{}{}", prefix, "Parameter"),
&obj.parameters,
);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct ModifyClusterResult {
pub cluster: Option<Cluster>,
}
#[allow(dead_code)]
struct ModifyClusterResultDeserializer;
impl ModifyClusterResultDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ModifyClusterResult, XmlParseError> {
deserialize_elements::<_, ModifyClusterResult, _>(tag_name, stack, |name, stack, obj| {
match name {
"Cluster" => {
obj.cluster = Some(ClusterDeserializer::deserialize("Cluster", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ModifyClusterSnapshotMessage {
pub force: Option<bool>,
pub manual_snapshot_retention_period: Option<i64>,
pub snapshot_identifier: String,
}
struct ModifyClusterSnapshotMessageSerializer;
impl ModifyClusterSnapshotMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ModifyClusterSnapshotMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.force {
params.put(&format!("{}{}", prefix, "Force"), &field_value);
}
if let Some(ref field_value) = obj.manual_snapshot_retention_period {
params.put(
&format!("{}{}", prefix, "ManualSnapshotRetentionPeriod"),
&field_value,
);
}
params.put(
&format!("{}{}", prefix, "SnapshotIdentifier"),
&obj.snapshot_identifier,
);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct ModifyClusterSnapshotResult {
pub snapshot: Option<Snapshot>,
}
#[allow(dead_code)]
struct ModifyClusterSnapshotResultDeserializer;
impl ModifyClusterSnapshotResultDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ModifyClusterSnapshotResult, XmlParseError> {
deserialize_elements::<_, ModifyClusterSnapshotResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"Snapshot" => {
obj.snapshot = Some(SnapshotDeserializer::deserialize("Snapshot", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ModifyClusterSnapshotScheduleMessage {
pub cluster_identifier: String,
pub disassociate_schedule: Option<bool>,
pub schedule_identifier: Option<String>,
}
struct ModifyClusterSnapshotScheduleMessageSerializer;
impl ModifyClusterSnapshotScheduleMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ModifyClusterSnapshotScheduleMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "ClusterIdentifier"),
&obj.cluster_identifier,
);
if let Some(ref field_value) = obj.disassociate_schedule {
params.put(
&format!("{}{}", prefix, "DisassociateSchedule"),
&field_value,
);
}
if let Some(ref field_value) = obj.schedule_identifier {
params.put(&format!("{}{}", prefix, "ScheduleIdentifier"), &field_value);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ModifyClusterSubnetGroupMessage {
pub cluster_subnet_group_name: String,
pub description: Option<String>,
pub subnet_ids: Vec<String>,
}
struct ModifyClusterSubnetGroupMessageSerializer;
impl ModifyClusterSubnetGroupMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ModifyClusterSubnetGroupMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "ClusterSubnetGroupName"),
&obj.cluster_subnet_group_name,
);
if let Some(ref field_value) = obj.description {
params.put(&format!("{}{}", prefix, "Description"), &field_value);
}
SubnetIdentifierListSerializer::serialize(
params,
&format!("{}{}", prefix, "SubnetIdentifier"),
&obj.subnet_ids,
);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct ModifyClusterSubnetGroupResult {
pub cluster_subnet_group: Option<ClusterSubnetGroup>,
}
#[allow(dead_code)]
struct ModifyClusterSubnetGroupResultDeserializer;
impl ModifyClusterSubnetGroupResultDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ModifyClusterSubnetGroupResult, XmlParseError> {
deserialize_elements::<_, ModifyClusterSubnetGroupResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"ClusterSubnetGroup" => {
obj.cluster_subnet_group =
Some(ClusterSubnetGroupDeserializer::deserialize(
"ClusterSubnetGroup",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ModifyEventSubscriptionMessage {
pub enabled: Option<bool>,
pub event_categories: Option<Vec<String>>,
pub severity: Option<String>,
pub sns_topic_arn: Option<String>,
pub source_ids: Option<Vec<String>>,
pub source_type: Option<String>,
pub subscription_name: String,
}
struct ModifyEventSubscriptionMessageSerializer;
impl ModifyEventSubscriptionMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ModifyEventSubscriptionMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.enabled {
params.put(&format!("{}{}", prefix, "Enabled"), &field_value);
}
if let Some(ref field_value) = obj.event_categories {
EventCategoriesListSerializer::serialize(
params,
&format!("{}{}", prefix, "EventCategory"),
field_value,
);
}
if let Some(ref field_value) = obj.severity {
params.put(&format!("{}{}", prefix, "Severity"), &field_value);
}
if let Some(ref field_value) = obj.sns_topic_arn {
params.put(&format!("{}{}", prefix, "SnsTopicArn"), &field_value);
}
if let Some(ref field_value) = obj.source_ids {
SourceIdsListSerializer::serialize(
params,
&format!("{}{}", prefix, "SourceId"),
field_value,
);
}
if let Some(ref field_value) = obj.source_type {
params.put(&format!("{}{}", prefix, "SourceType"), &field_value);
}
params.put(
&format!("{}{}", prefix, "SubscriptionName"),
&obj.subscription_name,
);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct ModifyEventSubscriptionResult {
pub event_subscription: Option<EventSubscription>,
}
#[allow(dead_code)]
struct ModifyEventSubscriptionResultDeserializer;
impl ModifyEventSubscriptionResultDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ModifyEventSubscriptionResult, XmlParseError> {
deserialize_elements::<_, ModifyEventSubscriptionResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"EventSubscription" => {
obj.event_subscription = Some(EventSubscriptionDeserializer::deserialize(
"EventSubscription",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ModifyScheduledActionMessage {
pub enable: Option<bool>,
pub end_time: Option<String>,
pub iam_role: Option<String>,
pub schedule: Option<String>,
pub scheduled_action_description: Option<String>,
pub scheduled_action_name: String,
pub start_time: Option<String>,
pub target_action: Option<ScheduledActionType>,
}
struct ModifyScheduledActionMessageSerializer;
impl ModifyScheduledActionMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ModifyScheduledActionMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.enable {
params.put(&format!("{}{}", prefix, "Enable"), &field_value);
}
if let Some(ref field_value) = obj.end_time {
params.put(&format!("{}{}", prefix, "EndTime"), &field_value);
}
if let Some(ref field_value) = obj.iam_role {
params.put(&format!("{}{}", prefix, "IamRole"), &field_value);
}
if let Some(ref field_value) = obj.schedule {
params.put(&format!("{}{}", prefix, "Schedule"), &field_value);
}
if let Some(ref field_value) = obj.scheduled_action_description {
params.put(
&format!("{}{}", prefix, "ScheduledActionDescription"),
&field_value,
);
}
params.put(
&format!("{}{}", prefix, "ScheduledActionName"),
&obj.scheduled_action_name,
);
if let Some(ref field_value) = obj.start_time {
params.put(&format!("{}{}", prefix, "StartTime"), &field_value);
}
if let Some(ref field_value) = obj.target_action {
ScheduledActionTypeSerializer::serialize(
params,
&format!("{}{}", prefix, "TargetAction"),
field_value,
);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ModifySnapshotCopyRetentionPeriodMessage {
pub cluster_identifier: String,
pub manual: Option<bool>,
pub retention_period: i64,
}
struct ModifySnapshotCopyRetentionPeriodMessageSerializer;
impl ModifySnapshotCopyRetentionPeriodMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ModifySnapshotCopyRetentionPeriodMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "ClusterIdentifier"),
&obj.cluster_identifier,
);
if let Some(ref field_value) = obj.manual {
params.put(&format!("{}{}", prefix, "Manual"), &field_value);
}
params.put(
&format!("{}{}", prefix, "RetentionPeriod"),
&obj.retention_period,
);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct ModifySnapshotCopyRetentionPeriodResult {
pub cluster: Option<Cluster>,
}
#[allow(dead_code)]
struct ModifySnapshotCopyRetentionPeriodResultDeserializer;
impl ModifySnapshotCopyRetentionPeriodResultDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ModifySnapshotCopyRetentionPeriodResult, XmlParseError> {
deserialize_elements::<_, ModifySnapshotCopyRetentionPeriodResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"Cluster" => {
obj.cluster = Some(ClusterDeserializer::deserialize("Cluster", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ModifySnapshotScheduleMessage {
pub schedule_definitions: Vec<String>,
pub schedule_identifier: String,
}
struct ModifySnapshotScheduleMessageSerializer;
impl ModifySnapshotScheduleMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ModifySnapshotScheduleMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
ScheduleDefinitionListSerializer::serialize(
params,
&format!("{}{}", prefix, "ScheduleDefinition"),
&obj.schedule_definitions,
);
params.put(
&format!("{}{}", prefix, "ScheduleIdentifier"),
&obj.schedule_identifier,
);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ModifyUsageLimitMessage {
pub amount: Option<i64>,
pub breach_action: Option<String>,
pub usage_limit_id: String,
}
struct ModifyUsageLimitMessageSerializer;
impl ModifyUsageLimitMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ModifyUsageLimitMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.amount {
params.put(&format!("{}{}", prefix, "Amount"), &field_value);
}
if let Some(ref field_value) = obj.breach_action {
params.put(&format!("{}{}", prefix, "BreachAction"), &field_value);
}
params.put(
&format!("{}{}", prefix, "UsageLimitId"),
&obj.usage_limit_id,
);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct NodeConfigurationOption {
pub estimated_disk_utilization_percent: Option<f64>,
pub mode: Option<String>,
pub node_type: Option<String>,
pub number_of_nodes: Option<i64>,
}
#[allow(dead_code)]
struct NodeConfigurationOptionDeserializer;
impl NodeConfigurationOptionDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<NodeConfigurationOption, XmlParseError> {
deserialize_elements::<_, NodeConfigurationOption, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"EstimatedDiskUtilizationPercent" => {
obj.estimated_disk_utilization_percent =
Some(DoubleOptionalDeserializer::deserialize(
"EstimatedDiskUtilizationPercent",
stack,
)?);
}
"Mode" => {
obj.mode = Some(ModeDeserializer::deserialize("Mode", stack)?);
}
"NodeType" => {
obj.node_type = Some(StringDeserializer::deserialize("NodeType", stack)?);
}
"NumberOfNodes" => {
obj.number_of_nodes =
Some(IntegerDeserializer::deserialize("NumberOfNodes", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[allow(dead_code)]
struct NodeConfigurationOptionListDeserializer;
impl NodeConfigurationOptionListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<NodeConfigurationOption>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "NodeConfigurationOption" {
obj.push(NodeConfigurationOptionDeserializer::deserialize(
"NodeConfigurationOption",
stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct NodeConfigurationOptionsFilter {
pub name: Option<String>,
pub operator: Option<String>,
pub values: Option<Vec<String>>,
}
struct NodeConfigurationOptionsFilterSerializer;
impl NodeConfigurationOptionsFilterSerializer {
fn serialize(params: &mut Params, name: &str, obj: &NodeConfigurationOptionsFilter) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.name {
params.put(&format!("{}{}", prefix, "Name"), &field_value);
}
if let Some(ref field_value) = obj.operator {
params.put(&format!("{}{}", prefix, "Operator"), &field_value);
}
if let Some(ref field_value) = obj.values {
ValueStringListSerializer::serialize(
params,
&format!("{}{}", prefix, "item"),
field_value,
);
}
}
}
struct NodeConfigurationOptionsFilterListSerializer;
impl NodeConfigurationOptionsFilterListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<NodeConfigurationOptionsFilter>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.member.{}", name, index + 1);
NodeConfigurationOptionsFilterSerializer::serialize(params, &key, obj);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct NodeConfigurationOptionsMessage {
pub marker: Option<String>,
pub node_configuration_option_list: Option<Vec<NodeConfigurationOption>>,
}
#[allow(dead_code)]
struct NodeConfigurationOptionsMessageDeserializer;
impl NodeConfigurationOptionsMessageDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<NodeConfigurationOptionsMessage, XmlParseError> {
deserialize_elements::<_, NodeConfigurationOptionsMessage, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"Marker" => {
obj.marker = Some(StringDeserializer::deserialize("Marker", stack)?);
}
"NodeConfigurationOptionList" => {
obj.node_configuration_option_list
.get_or_insert(vec![])
.extend(NodeConfigurationOptionListDeserializer::deserialize(
"NodeConfigurationOptionList",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct OrderableClusterOption {
pub availability_zones: Option<Vec<AvailabilityZone>>,
pub cluster_type: Option<String>,
pub cluster_version: Option<String>,
pub node_type: Option<String>,
}
#[allow(dead_code)]
struct OrderableClusterOptionDeserializer;
impl OrderableClusterOptionDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<OrderableClusterOption, XmlParseError> {
deserialize_elements::<_, OrderableClusterOption, _>(tag_name, stack, |name, stack, obj| {
match name {
"AvailabilityZones" => {
obj.availability_zones.get_or_insert(vec![]).extend(
AvailabilityZoneListDeserializer::deserialize("AvailabilityZones", stack)?,
);
}
"ClusterType" => {
obj.cluster_type = Some(StringDeserializer::deserialize("ClusterType", stack)?);
}
"ClusterVersion" => {
obj.cluster_version =
Some(StringDeserializer::deserialize("ClusterVersion", stack)?);
}
"NodeType" => {
obj.node_type = Some(StringDeserializer::deserialize("NodeType", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[allow(dead_code)]
struct OrderableClusterOptionsListDeserializer;
impl OrderableClusterOptionsListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<OrderableClusterOption>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "OrderableClusterOption" {
obj.push(OrderableClusterOptionDeserializer::deserialize(
"OrderableClusterOption",
stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct OrderableClusterOptionsMessage {
pub marker: Option<String>,
pub orderable_cluster_options: Option<Vec<OrderableClusterOption>>,
}
#[allow(dead_code)]
struct OrderableClusterOptionsMessageDeserializer;
impl OrderableClusterOptionsMessageDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<OrderableClusterOptionsMessage, XmlParseError> {
deserialize_elements::<_, OrderableClusterOptionsMessage, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"Marker" => {
obj.marker = Some(StringDeserializer::deserialize("Marker", stack)?);
}
"OrderableClusterOptions" => {
obj.orderable_cluster_options.get_or_insert(vec![]).extend(
OrderableClusterOptionsListDeserializer::deserialize(
"OrderableClusterOptions",
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 Parameter {
pub allowed_values: Option<String>,
pub apply_type: Option<String>,
pub data_type: Option<String>,
pub description: Option<String>,
pub is_modifiable: Option<bool>,
pub minimum_engine_version: Option<String>,
pub parameter_name: Option<String>,
pub parameter_value: Option<String>,
pub source: Option<String>,
}
#[allow(dead_code)]
struct ParameterDeserializer;
impl ParameterDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Parameter, XmlParseError> {
deserialize_elements::<_, Parameter, _>(tag_name, stack, |name, stack, obj| {
match name {
"AllowedValues" => {
obj.allowed_values =
Some(StringDeserializer::deserialize("AllowedValues", stack)?);
}
"ApplyType" => {
obj.apply_type = Some(ParameterApplyTypeDeserializer::deserialize(
"ApplyType",
stack,
)?);
}
"DataType" => {
obj.data_type = Some(StringDeserializer::deserialize("DataType", stack)?);
}
"Description" => {
obj.description = Some(StringDeserializer::deserialize("Description", stack)?);
}
"IsModifiable" => {
obj.is_modifiable =
Some(BooleanDeserializer::deserialize("IsModifiable", stack)?);
}
"MinimumEngineVersion" => {
obj.minimum_engine_version = Some(StringDeserializer::deserialize(
"MinimumEngineVersion",
stack,
)?);
}
"ParameterName" => {
obj.parameter_name =
Some(StringDeserializer::deserialize("ParameterName", stack)?);
}
"ParameterValue" => {
obj.parameter_value =
Some(StringDeserializer::deserialize("ParameterValue", stack)?);
}
"Source" => {
obj.source = Some(StringDeserializer::deserialize("Source", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct ParameterSerializer;
impl ParameterSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Parameter) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.allowed_values {
params.put(&format!("{}{}", prefix, "AllowedValues"), &field_value);
}
if let Some(ref field_value) = obj.apply_type {
params.put(&format!("{}{}", prefix, "ApplyType"), &field_value);
}
if let Some(ref field_value) = obj.data_type {
params.put(&format!("{}{}", prefix, "DataType"), &field_value);
}
if let Some(ref field_value) = obj.description {
params.put(&format!("{}{}", prefix, "Description"), &field_value);
}
if let Some(ref field_value) = obj.is_modifiable {
params.put(&format!("{}{}", prefix, "IsModifiable"), &field_value);
}
if let Some(ref field_value) = obj.minimum_engine_version {
params.put(
&format!("{}{}", prefix, "MinimumEngineVersion"),
&field_value,
);
}
if let Some(ref field_value) = obj.parameter_name {
params.put(&format!("{}{}", prefix, "ParameterName"), &field_value);
}
if let Some(ref field_value) = obj.parameter_value {
params.put(&format!("{}{}", prefix, "ParameterValue"), &field_value);
}
if let Some(ref field_value) = obj.source {
params.put(&format!("{}{}", prefix, "Source"), &field_value);
}
}
}
#[allow(dead_code)]
struct ParameterApplyTypeDeserializer;
impl ParameterApplyTypeDeserializer {
#[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 ParameterGroupListDeserializer;
impl ParameterGroupListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<ClusterParameterGroup>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "ClusterParameterGroup" {
obj.push(ClusterParameterGroupDeserializer::deserialize(
"ClusterParameterGroup",
stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[allow(dead_code)]
struct ParametersListDeserializer;
impl ParametersListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<Parameter>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "Parameter" {
obj.push(ParameterDeserializer::deserialize("Parameter", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct ParametersListSerializer;
impl ParametersListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<Parameter>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.member.{}", name, index + 1);
ParameterSerializer::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 PauseClusterMessage {
pub cluster_identifier: String,
}
#[allow(dead_code)]
struct PauseClusterMessageDeserializer;
impl PauseClusterMessageDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<PauseClusterMessage, XmlParseError> {
deserialize_elements::<_, PauseClusterMessage, _>(tag_name, stack, |name, stack, obj| {
match name {
"ClusterIdentifier" => {
obj.cluster_identifier =
StringDeserializer::deserialize("ClusterIdentifier", stack)?;
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct PauseClusterMessageSerializer;
impl PauseClusterMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &PauseClusterMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "ClusterIdentifier"),
&obj.cluster_identifier,
);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct PauseClusterResult {
pub cluster: Option<Cluster>,
}
#[allow(dead_code)]
struct PauseClusterResultDeserializer;
impl PauseClusterResultDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<PauseClusterResult, XmlParseError> {
deserialize_elements::<_, PauseClusterResult, _>(tag_name, stack, |name, stack, obj| {
match name {
"Cluster" => {
obj.cluster = Some(ClusterDeserializer::deserialize("Cluster", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[allow(dead_code)]
struct PendingActionsListDeserializer;
impl PendingActionsListDeserializer {
#[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(StringDeserializer::deserialize("member", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct PendingModifiedValues {
pub automated_snapshot_retention_period: Option<i64>,
pub cluster_identifier: Option<String>,
pub cluster_type: Option<String>,
pub cluster_version: Option<String>,
pub encryption_type: Option<String>,
pub enhanced_vpc_routing: Option<bool>,
pub maintenance_track_name: Option<String>,
pub master_user_password: Option<String>,
pub node_type: Option<String>,
pub number_of_nodes: Option<i64>,
pub publicly_accessible: Option<bool>,
}
#[allow(dead_code)]
struct PendingModifiedValuesDeserializer;
impl PendingModifiedValuesDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<PendingModifiedValues, XmlParseError> {
deserialize_elements::<_, PendingModifiedValues, _>(tag_name, stack, |name, stack, obj| {
match name {
"AutomatedSnapshotRetentionPeriod" => {
obj.automated_snapshot_retention_period =
Some(IntegerOptionalDeserializer::deserialize(
"AutomatedSnapshotRetentionPeriod",
stack,
)?);
}
"ClusterIdentifier" => {
obj.cluster_identifier =
Some(StringDeserializer::deserialize("ClusterIdentifier", stack)?);
}
"ClusterType" => {
obj.cluster_type = Some(StringDeserializer::deserialize("ClusterType", stack)?);
}
"ClusterVersion" => {
obj.cluster_version =
Some(StringDeserializer::deserialize("ClusterVersion", stack)?);
}
"EncryptionType" => {
obj.encryption_type =
Some(StringDeserializer::deserialize("EncryptionType", stack)?);
}
"EnhancedVpcRouting" => {
obj.enhanced_vpc_routing = Some(BooleanOptionalDeserializer::deserialize(
"EnhancedVpcRouting",
stack,
)?);
}
"MaintenanceTrackName" => {
obj.maintenance_track_name = Some(StringDeserializer::deserialize(
"MaintenanceTrackName",
stack,
)?);
}
"MasterUserPassword" => {
obj.master_user_password = Some(StringDeserializer::deserialize(
"MasterUserPassword",
stack,
)?);
}
"NodeType" => {
obj.node_type = Some(StringDeserializer::deserialize("NodeType", stack)?);
}
"NumberOfNodes" => {
obj.number_of_nodes = Some(IntegerOptionalDeserializer::deserialize(
"NumberOfNodes",
stack,
)?);
}
"PubliclyAccessible" => {
obj.publicly_accessible = Some(BooleanOptionalDeserializer::deserialize(
"PubliclyAccessible",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct PurchaseReservedNodeOfferingMessage {
pub node_count: Option<i64>,
pub reserved_node_offering_id: String,
}
struct PurchaseReservedNodeOfferingMessageSerializer;
impl PurchaseReservedNodeOfferingMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &PurchaseReservedNodeOfferingMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.node_count {
params.put(&format!("{}{}", prefix, "NodeCount"), &field_value);
}
params.put(
&format!("{}{}", prefix, "ReservedNodeOfferingId"),
&obj.reserved_node_offering_id,
);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct PurchaseReservedNodeOfferingResult {
pub reserved_node: Option<ReservedNode>,
}
#[allow(dead_code)]
struct PurchaseReservedNodeOfferingResultDeserializer;
impl PurchaseReservedNodeOfferingResultDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<PurchaseReservedNodeOfferingResult, XmlParseError> {
deserialize_elements::<_, PurchaseReservedNodeOfferingResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"ReservedNode" => {
obj.reserved_node = Some(ReservedNodeDeserializer::deserialize(
"ReservedNode",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct RebootClusterMessage {
pub cluster_identifier: String,
}
struct RebootClusterMessageSerializer;
impl RebootClusterMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &RebootClusterMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "ClusterIdentifier"),
&obj.cluster_identifier,
);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct RebootClusterResult {
pub cluster: Option<Cluster>,
}
#[allow(dead_code)]
struct RebootClusterResultDeserializer;
impl RebootClusterResultDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<RebootClusterResult, XmlParseError> {
deserialize_elements::<_, RebootClusterResult, _>(tag_name, stack, |name, stack, obj| {
match name {
"Cluster" => {
obj.cluster = Some(ClusterDeserializer::deserialize("Cluster", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct RecurringCharge {
pub recurring_charge_amount: Option<f64>,
pub recurring_charge_frequency: Option<String>,
}
#[allow(dead_code)]
struct RecurringChargeDeserializer;
impl RecurringChargeDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<RecurringCharge, XmlParseError> {
deserialize_elements::<_, RecurringCharge, _>(tag_name, stack, |name, stack, obj| {
match name {
"RecurringChargeAmount" => {
obj.recurring_charge_amount = Some(DoubleDeserializer::deserialize(
"RecurringChargeAmount",
stack,
)?);
}
"RecurringChargeFrequency" => {
obj.recurring_charge_frequency = Some(StringDeserializer::deserialize(
"RecurringChargeFrequency",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[allow(dead_code)]
struct RecurringChargeListDeserializer;
impl RecurringChargeListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<RecurringCharge>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "RecurringCharge" {
obj.push(RecurringChargeDeserializer::deserialize(
"RecurringCharge",
stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct ReservedNode {
pub currency_code: Option<String>,
pub duration: Option<i64>,
pub fixed_price: Option<f64>,
pub node_count: Option<i64>,
pub node_type: Option<String>,
pub offering_type: Option<String>,
pub recurring_charges: Option<Vec<RecurringCharge>>,
pub reserved_node_id: Option<String>,
pub reserved_node_offering_id: Option<String>,
pub reserved_node_offering_type: Option<String>,
pub start_time: Option<String>,
pub state: Option<String>,
pub usage_price: Option<f64>,
}
#[allow(dead_code)]
struct ReservedNodeDeserializer;
impl ReservedNodeDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ReservedNode, XmlParseError> {
deserialize_elements::<_, ReservedNode, _>(tag_name, stack, |name, stack, obj| {
match name {
"CurrencyCode" => {
obj.currency_code =
Some(StringDeserializer::deserialize("CurrencyCode", stack)?);
}
"Duration" => {
obj.duration = Some(IntegerDeserializer::deserialize("Duration", stack)?);
}
"FixedPrice" => {
obj.fixed_price = Some(DoubleDeserializer::deserialize("FixedPrice", stack)?);
}
"NodeCount" => {
obj.node_count = Some(IntegerDeserializer::deserialize("NodeCount", stack)?);
}
"NodeType" => {
obj.node_type = Some(StringDeserializer::deserialize("NodeType", stack)?);
}
"OfferingType" => {
obj.offering_type =
Some(StringDeserializer::deserialize("OfferingType", stack)?);
}
"RecurringCharges" => {
obj.recurring_charges.get_or_insert(vec![]).extend(
RecurringChargeListDeserializer::deserialize("RecurringCharges", stack)?,
);
}
"ReservedNodeId" => {
obj.reserved_node_id =
Some(StringDeserializer::deserialize("ReservedNodeId", stack)?);
}
"ReservedNodeOfferingId" => {
obj.reserved_node_offering_id = Some(StringDeserializer::deserialize(
"ReservedNodeOfferingId",
stack,
)?);
}
"ReservedNodeOfferingType" => {
obj.reserved_node_offering_type =
Some(ReservedNodeOfferingTypeDeserializer::deserialize(
"ReservedNodeOfferingType",
stack,
)?);
}
"StartTime" => {
obj.start_time = Some(TStampDeserializer::deserialize("StartTime", stack)?);
}
"State" => {
obj.state = Some(StringDeserializer::deserialize("State", stack)?);
}
"UsagePrice" => {
obj.usage_price = Some(DoubleDeserializer::deserialize("UsagePrice", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[allow(dead_code)]
struct ReservedNodeListDeserializer;
impl ReservedNodeListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<ReservedNode>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "ReservedNode" {
obj.push(ReservedNodeDeserializer::deserialize(
"ReservedNode",
stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct ReservedNodeOffering {
pub currency_code: Option<String>,
pub duration: Option<i64>,
pub fixed_price: Option<f64>,
pub node_type: Option<String>,
pub offering_type: Option<String>,
pub recurring_charges: Option<Vec<RecurringCharge>>,
pub reserved_node_offering_id: Option<String>,
pub reserved_node_offering_type: Option<String>,
pub usage_price: Option<f64>,
}
#[allow(dead_code)]
struct ReservedNodeOfferingDeserializer;
impl ReservedNodeOfferingDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ReservedNodeOffering, XmlParseError> {
deserialize_elements::<_, ReservedNodeOffering, _>(tag_name, stack, |name, stack, obj| {
match name {
"CurrencyCode" => {
obj.currency_code =
Some(StringDeserializer::deserialize("CurrencyCode", stack)?);
}
"Duration" => {
obj.duration = Some(IntegerDeserializer::deserialize("Duration", stack)?);
}
"FixedPrice" => {
obj.fixed_price = Some(DoubleDeserializer::deserialize("FixedPrice", stack)?);
}
"NodeType" => {
obj.node_type = Some(StringDeserializer::deserialize("NodeType", stack)?);
}
"OfferingType" => {
obj.offering_type =
Some(StringDeserializer::deserialize("OfferingType", stack)?);
}
"RecurringCharges" => {
obj.recurring_charges.get_or_insert(vec![]).extend(
RecurringChargeListDeserializer::deserialize("RecurringCharges", stack)?,
);
}
"ReservedNodeOfferingId" => {
obj.reserved_node_offering_id = Some(StringDeserializer::deserialize(
"ReservedNodeOfferingId",
stack,
)?);
}
"ReservedNodeOfferingType" => {
obj.reserved_node_offering_type =
Some(ReservedNodeOfferingTypeDeserializer::deserialize(
"ReservedNodeOfferingType",
stack,
)?);
}
"UsagePrice" => {
obj.usage_price = Some(DoubleDeserializer::deserialize("UsagePrice", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[allow(dead_code)]
struct ReservedNodeOfferingListDeserializer;
impl ReservedNodeOfferingListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<ReservedNodeOffering>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "ReservedNodeOffering" {
obj.push(ReservedNodeOfferingDeserializer::deserialize(
"ReservedNodeOffering",
stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[allow(dead_code)]
struct ReservedNodeOfferingTypeDeserializer;
impl ReservedNodeOfferingTypeDeserializer {
#[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 ReservedNodeOfferingsMessage {
pub marker: Option<String>,
pub reserved_node_offerings: Option<Vec<ReservedNodeOffering>>,
}
#[allow(dead_code)]
struct ReservedNodeOfferingsMessageDeserializer;
impl ReservedNodeOfferingsMessageDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ReservedNodeOfferingsMessage, XmlParseError> {
deserialize_elements::<_, ReservedNodeOfferingsMessage, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"Marker" => {
obj.marker = Some(StringDeserializer::deserialize("Marker", stack)?);
}
"ReservedNodeOfferings" => {
obj.reserved_node_offerings.get_or_insert(vec![]).extend(
ReservedNodeOfferingListDeserializer::deserialize(
"ReservedNodeOfferings",
stack,
)?,
);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct ReservedNodesMessage {
pub marker: Option<String>,
pub reserved_nodes: Option<Vec<ReservedNode>>,
}
#[allow(dead_code)]
struct ReservedNodesMessageDeserializer;
impl ReservedNodesMessageDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ReservedNodesMessage, XmlParseError> {
deserialize_elements::<_, ReservedNodesMessage, _>(tag_name, stack, |name, stack, obj| {
match name {
"Marker" => {
obj.marker = Some(StringDeserializer::deserialize("Marker", stack)?);
}
"ReservedNodes" => {
obj.reserved_nodes.get_or_insert(vec![]).extend(
ReservedNodeListDeserializer::deserialize("ReservedNodes", stack)?,
);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ResetClusterParameterGroupMessage {
pub parameter_group_name: String,
pub parameters: Option<Vec<Parameter>>,
pub reset_all_parameters: Option<bool>,
}
struct ResetClusterParameterGroupMessageSerializer;
impl ResetClusterParameterGroupMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ResetClusterParameterGroupMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "ParameterGroupName"),
&obj.parameter_group_name,
);
if let Some(ref field_value) = obj.parameters {
ParametersListSerializer::serialize(
params,
&format!("{}{}", prefix, "Parameter"),
field_value,
);
}
if let Some(ref field_value) = obj.reset_all_parameters {
params.put(&format!("{}{}", prefix, "ResetAllParameters"), &field_value);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ResizeClusterMessage {
pub classic: Option<bool>,
pub cluster_identifier: String,
pub cluster_type: Option<String>,
pub node_type: Option<String>,
pub number_of_nodes: Option<i64>,
}
#[allow(dead_code)]
struct ResizeClusterMessageDeserializer;
impl ResizeClusterMessageDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ResizeClusterMessage, XmlParseError> {
deserialize_elements::<_, ResizeClusterMessage, _>(tag_name, stack, |name, stack, obj| {
match name {
"Classic" => {
obj.classic = Some(BooleanOptionalDeserializer::deserialize("Classic", stack)?);
}
"ClusterIdentifier" => {
obj.cluster_identifier =
StringDeserializer::deserialize("ClusterIdentifier", stack)?;
}
"ClusterType" => {
obj.cluster_type = Some(StringDeserializer::deserialize("ClusterType", stack)?);
}
"NodeType" => {
obj.node_type = Some(StringDeserializer::deserialize("NodeType", stack)?);
}
"NumberOfNodes" => {
obj.number_of_nodes =
Some(IntegerDeserializer::deserialize("NumberOfNodes", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct ResizeClusterMessageSerializer;
impl ResizeClusterMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ResizeClusterMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.classic {
params.put(&format!("{}{}", prefix, "Classic"), &field_value);
}
params.put(
&format!("{}{}", prefix, "ClusterIdentifier"),
&obj.cluster_identifier,
);
if let Some(ref field_value) = obj.cluster_type {
params.put(&format!("{}{}", prefix, "ClusterType"), &field_value);
}
if let Some(ref field_value) = obj.node_type {
params.put(&format!("{}{}", prefix, "NodeType"), &field_value);
}
if let Some(ref field_value) = obj.number_of_nodes {
params.put(&format!("{}{}", prefix, "NumberOfNodes"), &field_value);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct ResizeClusterResult {
pub cluster: Option<Cluster>,
}
#[allow(dead_code)]
struct ResizeClusterResultDeserializer;
impl ResizeClusterResultDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ResizeClusterResult, XmlParseError> {
deserialize_elements::<_, ResizeClusterResult, _>(tag_name, stack, |name, stack, obj| {
match name {
"Cluster" => {
obj.cluster = Some(ClusterDeserializer::deserialize("Cluster", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct ResizeInfo {
pub allow_cancel_resize: Option<bool>,
pub resize_type: Option<String>,
}
#[allow(dead_code)]
struct ResizeInfoDeserializer;
impl ResizeInfoDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ResizeInfo, XmlParseError> {
deserialize_elements::<_, ResizeInfo, _>(tag_name, stack, |name, stack, obj| {
match name {
"AllowCancelResize" => {
obj.allow_cancel_resize = Some(BooleanDeserializer::deserialize(
"AllowCancelResize",
stack,
)?);
}
"ResizeType" => {
obj.resize_type = Some(StringDeserializer::deserialize("ResizeType", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct ResizeProgressMessage {
pub avg_resize_rate_in_mega_bytes_per_second: Option<f64>,
pub data_transfer_progress_percent: Option<f64>,
pub elapsed_time_in_seconds: Option<i64>,
pub estimated_time_to_completion_in_seconds: Option<i64>,
pub import_tables_completed: Option<Vec<String>>,
pub import_tables_in_progress: Option<Vec<String>>,
pub import_tables_not_started: Option<Vec<String>>,
pub message: Option<String>,
pub progress_in_mega_bytes: Option<i64>,
pub resize_type: Option<String>,
pub status: Option<String>,
pub target_cluster_type: Option<String>,
pub target_encryption_type: Option<String>,
pub target_node_type: Option<String>,
pub target_number_of_nodes: Option<i64>,
pub total_resize_data_in_mega_bytes: Option<i64>,
}
#[allow(dead_code)]
struct ResizeProgressMessageDeserializer;
impl ResizeProgressMessageDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ResizeProgressMessage, XmlParseError> {
deserialize_elements::<_, ResizeProgressMessage, _>(tag_name, stack, |name, stack, obj| {
match name {
"AvgResizeRateInMegaBytesPerSecond" => {
obj.avg_resize_rate_in_mega_bytes_per_second =
Some(DoubleOptionalDeserializer::deserialize(
"AvgResizeRateInMegaBytesPerSecond",
stack,
)?);
}
"DataTransferProgressPercent" => {
obj.data_transfer_progress_percent =
Some(DoubleOptionalDeserializer::deserialize(
"DataTransferProgressPercent",
stack,
)?);
}
"ElapsedTimeInSeconds" => {
obj.elapsed_time_in_seconds = Some(LongOptionalDeserializer::deserialize(
"ElapsedTimeInSeconds",
stack,
)?);
}
"EstimatedTimeToCompletionInSeconds" => {
obj.estimated_time_to_completion_in_seconds =
Some(LongOptionalDeserializer::deserialize(
"EstimatedTimeToCompletionInSeconds",
stack,
)?);
}
"ImportTablesCompleted" => {
obj.import_tables_completed.get_or_insert(vec![]).extend(
ImportTablesCompletedDeserializer::deserialize(
"ImportTablesCompleted",
stack,
)?,
);
}
"ImportTablesInProgress" => {
obj.import_tables_in_progress.get_or_insert(vec![]).extend(
ImportTablesInProgressDeserializer::deserialize(
"ImportTablesInProgress",
stack,
)?,
);
}
"ImportTablesNotStarted" => {
obj.import_tables_not_started.get_or_insert(vec![]).extend(
ImportTablesNotStartedDeserializer::deserialize(
"ImportTablesNotStarted",
stack,
)?,
);
}
"Message" => {
obj.message = Some(StringDeserializer::deserialize("Message", stack)?);
}
"ProgressInMegaBytes" => {
obj.progress_in_mega_bytes = Some(LongOptionalDeserializer::deserialize(
"ProgressInMegaBytes",
stack,
)?);
}
"ResizeType" => {
obj.resize_type = Some(StringDeserializer::deserialize("ResizeType", stack)?);
}
"Status" => {
obj.status = Some(StringDeserializer::deserialize("Status", stack)?);
}
"TargetClusterType" => {
obj.target_cluster_type =
Some(StringDeserializer::deserialize("TargetClusterType", stack)?);
}
"TargetEncryptionType" => {
obj.target_encryption_type = Some(StringDeserializer::deserialize(
"TargetEncryptionType",
stack,
)?);
}
"TargetNodeType" => {
obj.target_node_type =
Some(StringDeserializer::deserialize("TargetNodeType", stack)?);
}
"TargetNumberOfNodes" => {
obj.target_number_of_nodes = Some(IntegerOptionalDeserializer::deserialize(
"TargetNumberOfNodes",
stack,
)?);
}
"TotalResizeDataInMegaBytes" => {
obj.total_resize_data_in_mega_bytes = Some(
LongOptionalDeserializer::deserialize("TotalResizeDataInMegaBytes", stack)?,
);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[allow(dead_code)]
struct RestorableNodeTypeListDeserializer;
impl RestorableNodeTypeListDeserializer {
#[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 == "NodeType" {
obj.push(StringDeserializer::deserialize("NodeType", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct RestoreFromClusterSnapshotMessage {
pub additional_info: Option<String>,
pub allow_version_upgrade: Option<bool>,
pub automated_snapshot_retention_period: Option<i64>,
pub availability_zone: Option<String>,
pub cluster_identifier: String,
pub cluster_parameter_group_name: Option<String>,
pub cluster_security_groups: Option<Vec<String>>,
pub cluster_subnet_group_name: Option<String>,
pub elastic_ip: Option<String>,
pub enhanced_vpc_routing: Option<bool>,
pub hsm_client_certificate_identifier: Option<String>,
pub hsm_configuration_identifier: Option<String>,
pub iam_roles: Option<Vec<String>>,
pub kms_key_id: Option<String>,
pub maintenance_track_name: Option<String>,
pub manual_snapshot_retention_period: Option<i64>,
pub node_type: Option<String>,
pub number_of_nodes: Option<i64>,
pub owner_account: Option<String>,
pub port: Option<i64>,
pub preferred_maintenance_window: Option<String>,
pub publicly_accessible: Option<bool>,
pub snapshot_cluster_identifier: Option<String>,
pub snapshot_identifier: String,
pub snapshot_schedule_identifier: Option<String>,
pub vpc_security_group_ids: Option<Vec<String>>,
}
struct RestoreFromClusterSnapshotMessageSerializer;
impl RestoreFromClusterSnapshotMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &RestoreFromClusterSnapshotMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.additional_info {
params.put(&format!("{}{}", prefix, "AdditionalInfo"), &field_value);
}
if let Some(ref field_value) = obj.allow_version_upgrade {
params.put(
&format!("{}{}", prefix, "AllowVersionUpgrade"),
&field_value,
);
}
if let Some(ref field_value) = obj.automated_snapshot_retention_period {
params.put(
&format!("{}{}", prefix, "AutomatedSnapshotRetentionPeriod"),
&field_value,
);
}
if let Some(ref field_value) = obj.availability_zone {
params.put(&format!("{}{}", prefix, "AvailabilityZone"), &field_value);
}
params.put(
&format!("{}{}", prefix, "ClusterIdentifier"),
&obj.cluster_identifier,
);
if let Some(ref field_value) = obj.cluster_parameter_group_name {
params.put(
&format!("{}{}", prefix, "ClusterParameterGroupName"),
&field_value,
);
}
if let Some(ref field_value) = obj.cluster_security_groups {
ClusterSecurityGroupNameListSerializer::serialize(
params,
&format!("{}{}", prefix, "ClusterSecurityGroupName"),
field_value,
);
}
if let Some(ref field_value) = obj.cluster_subnet_group_name {
params.put(
&format!("{}{}", prefix, "ClusterSubnetGroupName"),
&field_value,
);
}
if let Some(ref field_value) = obj.elastic_ip {
params.put(&format!("{}{}", prefix, "ElasticIp"), &field_value);
}
if let Some(ref field_value) = obj.enhanced_vpc_routing {
params.put(&format!("{}{}", prefix, "EnhancedVpcRouting"), &field_value);
}
if let Some(ref field_value) = obj.hsm_client_certificate_identifier {
params.put(
&format!("{}{}", prefix, "HsmClientCertificateIdentifier"),
&field_value,
);
}
if let Some(ref field_value) = obj.hsm_configuration_identifier {
params.put(
&format!("{}{}", prefix, "HsmConfigurationIdentifier"),
&field_value,
);
}
if let Some(ref field_value) = obj.iam_roles {
IamRoleArnListSerializer::serialize(
params,
&format!("{}{}", prefix, "IamRoleArn"),
field_value,
);
}
if let Some(ref field_value) = obj.kms_key_id {
params.put(&format!("{}{}", prefix, "KmsKeyId"), &field_value);
}
if let Some(ref field_value) = obj.maintenance_track_name {
params.put(
&format!("{}{}", prefix, "MaintenanceTrackName"),
&field_value,
);
}
if let Some(ref field_value) = obj.manual_snapshot_retention_period {
params.put(
&format!("{}{}", prefix, "ManualSnapshotRetentionPeriod"),
&field_value,
);
}
if let Some(ref field_value) = obj.node_type {
params.put(&format!("{}{}", prefix, "NodeType"), &field_value);
}
if let Some(ref field_value) = obj.number_of_nodes {
params.put(&format!("{}{}", prefix, "NumberOfNodes"), &field_value);
}
if let Some(ref field_value) = obj.owner_account {
params.put(&format!("{}{}", prefix, "OwnerAccount"), &field_value);
}
if let Some(ref field_value) = obj.port {
params.put(&format!("{}{}", prefix, "Port"), &field_value);
}
if let Some(ref field_value) = obj.preferred_maintenance_window {
params.put(
&format!("{}{}", prefix, "PreferredMaintenanceWindow"),
&field_value,
);
}
if let Some(ref field_value) = obj.publicly_accessible {
params.put(&format!("{}{}", prefix, "PubliclyAccessible"), &field_value);
}
if let Some(ref field_value) = obj.snapshot_cluster_identifier {
params.put(
&format!("{}{}", prefix, "SnapshotClusterIdentifier"),
&field_value,
);
}
params.put(
&format!("{}{}", prefix, "SnapshotIdentifier"),
&obj.snapshot_identifier,
);
if let Some(ref field_value) = obj.snapshot_schedule_identifier {
params.put(
&format!("{}{}", prefix, "SnapshotScheduleIdentifier"),
&field_value,
);
}
if let Some(ref field_value) = obj.vpc_security_group_ids {
VpcSecurityGroupIdListSerializer::serialize(
params,
&format!("{}{}", prefix, "VpcSecurityGroupId"),
field_value,
);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct RestoreFromClusterSnapshotResult {
pub cluster: Option<Cluster>,
}
#[allow(dead_code)]
struct RestoreFromClusterSnapshotResultDeserializer;
impl RestoreFromClusterSnapshotResultDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<RestoreFromClusterSnapshotResult, XmlParseError> {
deserialize_elements::<_, RestoreFromClusterSnapshotResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"Cluster" => {
obj.cluster = Some(ClusterDeserializer::deserialize("Cluster", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct RestoreStatus {
pub current_restore_rate_in_mega_bytes_per_second: Option<f64>,
pub elapsed_time_in_seconds: Option<i64>,
pub estimated_time_to_completion_in_seconds: Option<i64>,
pub progress_in_mega_bytes: Option<i64>,
pub snapshot_size_in_mega_bytes: Option<i64>,
pub status: Option<String>,
}
#[allow(dead_code)]
struct RestoreStatusDeserializer;
impl RestoreStatusDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<RestoreStatus, XmlParseError> {
deserialize_elements::<_, RestoreStatus, _>(tag_name, stack, |name, stack, obj| {
match name {
"CurrentRestoreRateInMegaBytesPerSecond" => {
obj.current_restore_rate_in_mega_bytes_per_second =
Some(DoubleDeserializer::deserialize(
"CurrentRestoreRateInMegaBytesPerSecond",
stack,
)?);
}
"ElapsedTimeInSeconds" => {
obj.elapsed_time_in_seconds = Some(LongDeserializer::deserialize(
"ElapsedTimeInSeconds",
stack,
)?);
}
"EstimatedTimeToCompletionInSeconds" => {
obj.estimated_time_to_completion_in_seconds = Some(
LongDeserializer::deserialize("EstimatedTimeToCompletionInSeconds", stack)?,
);
}
"ProgressInMegaBytes" => {
obj.progress_in_mega_bytes =
Some(LongDeserializer::deserialize("ProgressInMegaBytes", stack)?);
}
"SnapshotSizeInMegaBytes" => {
obj.snapshot_size_in_mega_bytes = Some(LongDeserializer::deserialize(
"SnapshotSizeInMegaBytes",
stack,
)?);
}
"Status" => {
obj.status = Some(StringDeserializer::deserialize("Status", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct RestoreTableFromClusterSnapshotMessage {
pub cluster_identifier: String,
pub new_table_name: String,
pub snapshot_identifier: String,
pub source_database_name: String,
pub source_schema_name: Option<String>,
pub source_table_name: String,
pub target_database_name: Option<String>,
pub target_schema_name: Option<String>,
}
struct RestoreTableFromClusterSnapshotMessageSerializer;
impl RestoreTableFromClusterSnapshotMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &RestoreTableFromClusterSnapshotMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "ClusterIdentifier"),
&obj.cluster_identifier,
);
params.put(
&format!("{}{}", prefix, "NewTableName"),
&obj.new_table_name,
);
params.put(
&format!("{}{}", prefix, "SnapshotIdentifier"),
&obj.snapshot_identifier,
);
params.put(
&format!("{}{}", prefix, "SourceDatabaseName"),
&obj.source_database_name,
);
if let Some(ref field_value) = obj.source_schema_name {
params.put(&format!("{}{}", prefix, "SourceSchemaName"), &field_value);
}
params.put(
&format!("{}{}", prefix, "SourceTableName"),
&obj.source_table_name,
);
if let Some(ref field_value) = obj.target_database_name {
params.put(&format!("{}{}", prefix, "TargetDatabaseName"), &field_value);
}
if let Some(ref field_value) = obj.target_schema_name {
params.put(&format!("{}{}", prefix, "TargetSchemaName"), &field_value);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct RestoreTableFromClusterSnapshotResult {
pub table_restore_status: Option<TableRestoreStatus>,
}
#[allow(dead_code)]
struct RestoreTableFromClusterSnapshotResultDeserializer;
impl RestoreTableFromClusterSnapshotResultDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<RestoreTableFromClusterSnapshotResult, XmlParseError> {
deserialize_elements::<_, RestoreTableFromClusterSnapshotResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"TableRestoreStatus" => {
obj.table_restore_status =
Some(TableRestoreStatusDeserializer::deserialize(
"TableRestoreStatus",
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 ResumeClusterMessage {
pub cluster_identifier: String,
}
#[allow(dead_code)]
struct ResumeClusterMessageDeserializer;
impl ResumeClusterMessageDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ResumeClusterMessage, XmlParseError> {
deserialize_elements::<_, ResumeClusterMessage, _>(tag_name, stack, |name, stack, obj| {
match name {
"ClusterIdentifier" => {
obj.cluster_identifier =
StringDeserializer::deserialize("ClusterIdentifier", stack)?;
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct ResumeClusterMessageSerializer;
impl ResumeClusterMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ResumeClusterMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "ClusterIdentifier"),
&obj.cluster_identifier,
);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct ResumeClusterResult {
pub cluster: Option<Cluster>,
}
#[allow(dead_code)]
struct ResumeClusterResultDeserializer;
impl ResumeClusterResultDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ResumeClusterResult, XmlParseError> {
deserialize_elements::<_, ResumeClusterResult, _>(tag_name, stack, |name, stack, obj| {
match name {
"Cluster" => {
obj.cluster = Some(ClusterDeserializer::deserialize("Cluster", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct RevisionTarget {
pub database_revision: Option<String>,
pub database_revision_release_date: Option<String>,
pub description: Option<String>,
}
#[allow(dead_code)]
struct RevisionTargetDeserializer;
impl RevisionTargetDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<RevisionTarget, XmlParseError> {
deserialize_elements::<_, RevisionTarget, _>(tag_name, stack, |name, stack, obj| {
match name {
"DatabaseRevision" => {
obj.database_revision =
Some(StringDeserializer::deserialize("DatabaseRevision", stack)?);
}
"DatabaseRevisionReleaseDate" => {
obj.database_revision_release_date = Some(TStampDeserializer::deserialize(
"DatabaseRevisionReleaseDate",
stack,
)?);
}
"Description" => {
obj.description = Some(StringDeserializer::deserialize("Description", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[allow(dead_code)]
struct RevisionTargetsListDeserializer;
impl RevisionTargetsListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<RevisionTarget>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "RevisionTarget" {
obj.push(RevisionTargetDeserializer::deserialize(
"RevisionTarget",
stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct RevokeClusterSecurityGroupIngressMessage {
pub cidrip: Option<String>,
pub cluster_security_group_name: String,
pub ec2_security_group_name: Option<String>,
pub ec2_security_group_owner_id: Option<String>,
}
struct RevokeClusterSecurityGroupIngressMessageSerializer;
impl RevokeClusterSecurityGroupIngressMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &RevokeClusterSecurityGroupIngressMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.cidrip {
params.put(&format!("{}{}", prefix, "CIDRIP"), &field_value);
}
params.put(
&format!("{}{}", prefix, "ClusterSecurityGroupName"),
&obj.cluster_security_group_name,
);
if let Some(ref field_value) = obj.ec2_security_group_name {
params.put(
&format!("{}{}", prefix, "EC2SecurityGroupName"),
&field_value,
);
}
if let Some(ref field_value) = obj.ec2_security_group_owner_id {
params.put(
&format!("{}{}", prefix, "EC2SecurityGroupOwnerId"),
&field_value,
);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct RevokeClusterSecurityGroupIngressResult {
pub cluster_security_group: Option<ClusterSecurityGroup>,
}
#[allow(dead_code)]
struct RevokeClusterSecurityGroupIngressResultDeserializer;
impl RevokeClusterSecurityGroupIngressResultDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<RevokeClusterSecurityGroupIngressResult, XmlParseError> {
deserialize_elements::<_, RevokeClusterSecurityGroupIngressResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"ClusterSecurityGroup" => {
obj.cluster_security_group =
Some(ClusterSecurityGroupDeserializer::deserialize(
"ClusterSecurityGroup",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct RevokeSnapshotAccessMessage {
pub account_with_restore_access: String,
pub snapshot_cluster_identifier: Option<String>,
pub snapshot_identifier: String,
}
struct RevokeSnapshotAccessMessageSerializer;
impl RevokeSnapshotAccessMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &RevokeSnapshotAccessMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "AccountWithRestoreAccess"),
&obj.account_with_restore_access,
);
if let Some(ref field_value) = obj.snapshot_cluster_identifier {
params.put(
&format!("{}{}", prefix, "SnapshotClusterIdentifier"),
&field_value,
);
}
params.put(
&format!("{}{}", prefix, "SnapshotIdentifier"),
&obj.snapshot_identifier,
);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct RevokeSnapshotAccessResult {
pub snapshot: Option<Snapshot>,
}
#[allow(dead_code)]
struct RevokeSnapshotAccessResultDeserializer;
impl RevokeSnapshotAccessResultDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<RevokeSnapshotAccessResult, XmlParseError> {
deserialize_elements::<_, RevokeSnapshotAccessResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"Snapshot" => {
obj.snapshot = Some(SnapshotDeserializer::deserialize("Snapshot", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct RotateEncryptionKeyMessage {
pub cluster_identifier: String,
}
struct RotateEncryptionKeyMessageSerializer;
impl RotateEncryptionKeyMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &RotateEncryptionKeyMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "ClusterIdentifier"),
&obj.cluster_identifier,
);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct RotateEncryptionKeyResult {
pub cluster: Option<Cluster>,
}
#[allow(dead_code)]
struct RotateEncryptionKeyResultDeserializer;
impl RotateEncryptionKeyResultDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<RotateEncryptionKeyResult, XmlParseError> {
deserialize_elements::<_, RotateEncryptionKeyResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"Cluster" => {
obj.cluster = Some(ClusterDeserializer::deserialize("Cluster", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[allow(dead_code)]
struct ScheduleDefinitionListDeserializer;
impl ScheduleDefinitionListDeserializer {
#[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 == "ScheduleDefinition" {
obj.push(StringDeserializer::deserialize(
"ScheduleDefinition",
stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct ScheduleDefinitionListSerializer;
impl ScheduleDefinitionListSerializer {
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 ScheduleStateDeserializer;
impl ScheduleStateDeserializer {
#[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 ScheduledAction {
pub end_time: Option<String>,
pub iam_role: Option<String>,
pub next_invocations: Option<Vec<String>>,
pub schedule: Option<String>,
pub scheduled_action_description: Option<String>,
pub scheduled_action_name: Option<String>,
pub start_time: Option<String>,
pub state: Option<String>,
pub target_action: Option<ScheduledActionType>,
}
#[allow(dead_code)]
struct ScheduledActionDeserializer;
impl ScheduledActionDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ScheduledAction, XmlParseError> {
deserialize_elements::<_, ScheduledAction, _>(tag_name, stack, |name, stack, obj| {
match name {
"EndTime" => {
obj.end_time = Some(TStampDeserializer::deserialize("EndTime", stack)?);
}
"IamRole" => {
obj.iam_role = Some(StringDeserializer::deserialize("IamRole", stack)?);
}
"NextInvocations" => {
obj.next_invocations.get_or_insert(vec![]).extend(
ScheduledActionTimeListDeserializer::deserialize("NextInvocations", stack)?,
);
}
"Schedule" => {
obj.schedule = Some(StringDeserializer::deserialize("Schedule", stack)?);
}
"ScheduledActionDescription" => {
obj.scheduled_action_description = Some(StringDeserializer::deserialize(
"ScheduledActionDescription",
stack,
)?);
}
"ScheduledActionName" => {
obj.scheduled_action_name = Some(StringDeserializer::deserialize(
"ScheduledActionName",
stack,
)?);
}
"StartTime" => {
obj.start_time = Some(TStampDeserializer::deserialize("StartTime", stack)?);
}
"State" => {
obj.state = Some(ScheduledActionStateDeserializer::deserialize(
"State", stack,
)?);
}
"TargetAction" => {
obj.target_action = Some(ScheduledActionTypeDeserializer::deserialize(
"TargetAction",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ScheduledActionFilter {
pub name: String,
pub values: Vec<String>,
}
struct ScheduledActionFilterSerializer;
impl ScheduledActionFilterSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ScheduledActionFilter) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(&format!("{}{}", prefix, "Name"), &obj.name);
ValueStringListSerializer::serialize(params, &format!("{}{}", prefix, "item"), &obj.values);
}
}
struct ScheduledActionFilterListSerializer;
impl ScheduledActionFilterListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<ScheduledActionFilter>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.member.{}", name, index + 1);
ScheduledActionFilterSerializer::serialize(params, &key, obj);
}
}
}
#[allow(dead_code)]
struct ScheduledActionListDeserializer;
impl ScheduledActionListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<ScheduledAction>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "ScheduledAction" {
obj.push(ScheduledActionDeserializer::deserialize(
"ScheduledAction",
stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[allow(dead_code)]
struct ScheduledActionStateDeserializer;
impl ScheduledActionStateDeserializer {
#[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 ScheduledActionTimeListDeserializer;
impl ScheduledActionTimeListDeserializer {
#[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 == "ScheduledActionTime" {
obj.push(TStampDeserializer::deserialize(
"ScheduledActionTime",
stack,
)?);
} else {
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 ScheduledActionType {
pub pause_cluster: Option<PauseClusterMessage>,
pub resize_cluster: Option<ResizeClusterMessage>,
pub resume_cluster: Option<ResumeClusterMessage>,
}
#[allow(dead_code)]
struct ScheduledActionTypeDeserializer;
impl ScheduledActionTypeDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ScheduledActionType, XmlParseError> {
deserialize_elements::<_, ScheduledActionType, _>(tag_name, stack, |name, stack, obj| {
match name {
"PauseCluster" => {
obj.pause_cluster = Some(PauseClusterMessageDeserializer::deserialize(
"PauseCluster",
stack,
)?);
}
"ResizeCluster" => {
obj.resize_cluster = Some(ResizeClusterMessageDeserializer::deserialize(
"ResizeCluster",
stack,
)?);
}
"ResumeCluster" => {
obj.resume_cluster = Some(ResumeClusterMessageDeserializer::deserialize(
"ResumeCluster",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct ScheduledActionTypeSerializer;
impl ScheduledActionTypeSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ScheduledActionType) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.pause_cluster {
PauseClusterMessageSerializer::serialize(
params,
&format!("{}{}", prefix, "PauseCluster"),
field_value,
);
}
if let Some(ref field_value) = obj.resize_cluster {
ResizeClusterMessageSerializer::serialize(
params,
&format!("{}{}", prefix, "ResizeCluster"),
field_value,
);
}
if let Some(ref field_value) = obj.resume_cluster {
ResumeClusterMessageSerializer::serialize(
params,
&format!("{}{}", prefix, "ResumeCluster"),
field_value,
);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct ScheduledActionsMessage {
pub marker: Option<String>,
pub scheduled_actions: Option<Vec<ScheduledAction>>,
}
#[allow(dead_code)]
struct ScheduledActionsMessageDeserializer;
impl ScheduledActionsMessageDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ScheduledActionsMessage, XmlParseError> {
deserialize_elements::<_, ScheduledActionsMessage, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"Marker" => {
obj.marker = Some(StringDeserializer::deserialize("Marker", stack)?);
}
"ScheduledActions" => {
obj.scheduled_actions.get_or_insert(vec![]).extend(
ScheduledActionListDeserializer::deserialize(
"ScheduledActions",
stack,
)?,
);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[allow(dead_code)]
struct ScheduledSnapshotTimeListDeserializer;
impl ScheduledSnapshotTimeListDeserializer {
#[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 == "SnapshotTime" {
obj.push(TStampDeserializer::deserialize("SnapshotTime", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[allow(dead_code)]
struct SensitiveStringDeserializer;
impl SensitiveStringDeserializer {
#[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 Snapshot {
pub accounts_with_restore_access: Option<Vec<AccountWithRestoreAccess>>,
pub actual_incremental_backup_size_in_mega_bytes: Option<f64>,
pub availability_zone: Option<String>,
pub backup_progress_in_mega_bytes: Option<f64>,
pub cluster_create_time: Option<String>,
pub cluster_identifier: Option<String>,
pub cluster_version: Option<String>,
pub current_backup_rate_in_mega_bytes_per_second: Option<f64>,
pub db_name: Option<String>,
pub elapsed_time_in_seconds: Option<i64>,
pub encrypted: Option<bool>,
pub encrypted_with_hsm: Option<bool>,
pub enhanced_vpc_routing: Option<bool>,
pub estimated_seconds_to_completion: Option<i64>,
pub kms_key_id: Option<String>,
pub maintenance_track_name: Option<String>,
pub manual_snapshot_remaining_days: Option<i64>,
pub manual_snapshot_retention_period: Option<i64>,
pub master_username: Option<String>,
pub node_type: Option<String>,
pub number_of_nodes: Option<i64>,
pub owner_account: Option<String>,
pub port: Option<i64>,
pub restorable_node_types: Option<Vec<String>>,
pub snapshot_create_time: Option<String>,
pub snapshot_identifier: Option<String>,
pub snapshot_retention_start_time: Option<String>,
pub snapshot_type: Option<String>,
pub source_region: Option<String>,
pub status: Option<String>,
pub tags: Option<Vec<Tag>>,
pub total_backup_size_in_mega_bytes: Option<f64>,
pub vpc_id: Option<String>,
}
#[allow(dead_code)]
struct SnapshotDeserializer;
impl SnapshotDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Snapshot, XmlParseError> {
deserialize_elements::<_, Snapshot, _>(tag_name, stack, |name, stack, obj| {
match name {
"AccountsWithRestoreAccess" => {
obj.accounts_with_restore_access
.get_or_insert(vec![])
.extend(AccountsWithRestoreAccessListDeserializer::deserialize(
"AccountsWithRestoreAccess",
stack,
)?);
}
"ActualIncrementalBackupSizeInMegaBytes" => {
obj.actual_incremental_backup_size_in_mega_bytes =
Some(DoubleDeserializer::deserialize(
"ActualIncrementalBackupSizeInMegaBytes",
stack,
)?);
}
"AvailabilityZone" => {
obj.availability_zone =
Some(StringDeserializer::deserialize("AvailabilityZone", stack)?);
}
"BackupProgressInMegaBytes" => {
obj.backup_progress_in_mega_bytes = Some(DoubleDeserializer::deserialize(
"BackupProgressInMegaBytes",
stack,
)?);
}
"ClusterCreateTime" => {
obj.cluster_create_time =
Some(TStampDeserializer::deserialize("ClusterCreateTime", stack)?);
}
"ClusterIdentifier" => {
obj.cluster_identifier =
Some(StringDeserializer::deserialize("ClusterIdentifier", stack)?);
}
"ClusterVersion" => {
obj.cluster_version =
Some(StringDeserializer::deserialize("ClusterVersion", stack)?);
}
"CurrentBackupRateInMegaBytesPerSecond" => {
obj.current_backup_rate_in_mega_bytes_per_second =
Some(DoubleDeserializer::deserialize(
"CurrentBackupRateInMegaBytesPerSecond",
stack,
)?);
}
"DBName" => {
obj.db_name = Some(StringDeserializer::deserialize("DBName", stack)?);
}
"ElapsedTimeInSeconds" => {
obj.elapsed_time_in_seconds = Some(LongDeserializer::deserialize(
"ElapsedTimeInSeconds",
stack,
)?);
}
"Encrypted" => {
obj.encrypted = Some(BooleanDeserializer::deserialize("Encrypted", stack)?);
}
"EncryptedWithHSM" => {
obj.encrypted_with_hsm =
Some(BooleanDeserializer::deserialize("EncryptedWithHSM", stack)?);
}
"EnhancedVpcRouting" => {
obj.enhanced_vpc_routing = Some(BooleanDeserializer::deserialize(
"EnhancedVpcRouting",
stack,
)?);
}
"EstimatedSecondsToCompletion" => {
obj.estimated_seconds_to_completion = Some(LongDeserializer::deserialize(
"EstimatedSecondsToCompletion",
stack,
)?);
}
"KmsKeyId" => {
obj.kms_key_id = Some(StringDeserializer::deserialize("KmsKeyId", stack)?);
}
"MaintenanceTrackName" => {
obj.maintenance_track_name = Some(StringDeserializer::deserialize(
"MaintenanceTrackName",
stack,
)?);
}
"ManualSnapshotRemainingDays" => {
obj.manual_snapshot_remaining_days =
Some(IntegerOptionalDeserializer::deserialize(
"ManualSnapshotRemainingDays",
stack,
)?);
}
"ManualSnapshotRetentionPeriod" => {
obj.manual_snapshot_retention_period =
Some(IntegerOptionalDeserializer::deserialize(
"ManualSnapshotRetentionPeriod",
stack,
)?);
}
"MasterUsername" => {
obj.master_username =
Some(StringDeserializer::deserialize("MasterUsername", stack)?);
}
"NodeType" => {
obj.node_type = Some(StringDeserializer::deserialize("NodeType", stack)?);
}
"NumberOfNodes" => {
obj.number_of_nodes =
Some(IntegerDeserializer::deserialize("NumberOfNodes", stack)?);
}
"OwnerAccount" => {
obj.owner_account =
Some(StringDeserializer::deserialize("OwnerAccount", stack)?);
}
"Port" => {
obj.port = Some(IntegerDeserializer::deserialize("Port", stack)?);
}
"RestorableNodeTypes" => {
obj.restorable_node_types.get_or_insert(vec![]).extend(
RestorableNodeTypeListDeserializer::deserialize(
"RestorableNodeTypes",
stack,
)?,
);
}
"SnapshotCreateTime" => {
obj.snapshot_create_time = Some(TStampDeserializer::deserialize(
"SnapshotCreateTime",
stack,
)?);
}
"SnapshotIdentifier" => {
obj.snapshot_identifier = Some(StringDeserializer::deserialize(
"SnapshotIdentifier",
stack,
)?);
}
"SnapshotRetentionStartTime" => {
obj.snapshot_retention_start_time = Some(TStampDeserializer::deserialize(
"SnapshotRetentionStartTime",
stack,
)?);
}
"SnapshotType" => {
obj.snapshot_type =
Some(StringDeserializer::deserialize("SnapshotType", stack)?);
}
"SourceRegion" => {
obj.source_region =
Some(StringDeserializer::deserialize("SourceRegion", stack)?);
}
"Status" => {
obj.status = Some(StringDeserializer::deserialize("Status", stack)?);
}
"Tags" => {
obj.tags
.get_or_insert(vec![])
.extend(TagListDeserializer::deserialize("Tags", stack)?);
}
"TotalBackupSizeInMegaBytes" => {
obj.total_backup_size_in_mega_bytes = Some(DoubleDeserializer::deserialize(
"TotalBackupSizeInMegaBytes",
stack,
)?);
}
"VpcId" => {
obj.vpc_id = Some(StringDeserializer::deserialize("VpcId", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct SnapshotCopyGrant {
pub kms_key_id: Option<String>,
pub snapshot_copy_grant_name: Option<String>,
pub tags: Option<Vec<Tag>>,
}
#[allow(dead_code)]
struct SnapshotCopyGrantDeserializer;
impl SnapshotCopyGrantDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<SnapshotCopyGrant, XmlParseError> {
deserialize_elements::<_, SnapshotCopyGrant, _>(tag_name, stack, |name, stack, obj| {
match name {
"KmsKeyId" => {
obj.kms_key_id = Some(StringDeserializer::deserialize("KmsKeyId", stack)?);
}
"SnapshotCopyGrantName" => {
obj.snapshot_copy_grant_name = Some(StringDeserializer::deserialize(
"SnapshotCopyGrantName",
stack,
)?);
}
"Tags" => {
obj.tags
.get_or_insert(vec![])
.extend(TagListDeserializer::deserialize("Tags", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[allow(dead_code)]
struct SnapshotCopyGrantListDeserializer;
impl SnapshotCopyGrantListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<SnapshotCopyGrant>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "SnapshotCopyGrant" {
obj.push(SnapshotCopyGrantDeserializer::deserialize(
"SnapshotCopyGrant",
stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct SnapshotCopyGrantMessage {
pub marker: Option<String>,
pub snapshot_copy_grants: Option<Vec<SnapshotCopyGrant>>,
}
#[allow(dead_code)]
struct SnapshotCopyGrantMessageDeserializer;
impl SnapshotCopyGrantMessageDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<SnapshotCopyGrantMessage, XmlParseError> {
deserialize_elements::<_, SnapshotCopyGrantMessage, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"Marker" => {
obj.marker = Some(StringDeserializer::deserialize("Marker", stack)?);
}
"SnapshotCopyGrants" => {
obj.snapshot_copy_grants.get_or_insert(vec![]).extend(
SnapshotCopyGrantListDeserializer::deserialize(
"SnapshotCopyGrants",
stack,
)?,
);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct SnapshotErrorMessage {
pub failure_code: Option<String>,
pub failure_reason: Option<String>,
pub snapshot_cluster_identifier: Option<String>,
pub snapshot_identifier: Option<String>,
}
#[allow(dead_code)]
struct SnapshotErrorMessageDeserializer;
impl SnapshotErrorMessageDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<SnapshotErrorMessage, XmlParseError> {
deserialize_elements::<_, SnapshotErrorMessage, _>(tag_name, stack, |name, stack, obj| {
match name {
"FailureCode" => {
obj.failure_code = Some(StringDeserializer::deserialize("FailureCode", stack)?);
}
"FailureReason" => {
obj.failure_reason =
Some(StringDeserializer::deserialize("FailureReason", stack)?);
}
"SnapshotClusterIdentifier" => {
obj.snapshot_cluster_identifier = Some(StringDeserializer::deserialize(
"SnapshotClusterIdentifier",
stack,
)?);
}
"SnapshotIdentifier" => {
obj.snapshot_identifier = Some(StringDeserializer::deserialize(
"SnapshotIdentifier",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[allow(dead_code)]
struct SnapshotIdentifierListDeserializer;
impl SnapshotIdentifierListDeserializer {
#[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 == "String" {
obj.push(StringDeserializer::deserialize("String", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct SnapshotIdentifierListSerializer;
impl SnapshotIdentifierListSerializer {
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 SnapshotListDeserializer;
impl SnapshotListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<Snapshot>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "Snapshot" {
obj.push(SnapshotDeserializer::deserialize("Snapshot", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct SnapshotMessage {
pub marker: Option<String>,
pub snapshots: Option<Vec<Snapshot>>,
}
#[allow(dead_code)]
struct SnapshotMessageDeserializer;
impl SnapshotMessageDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<SnapshotMessage, XmlParseError> {
deserialize_elements::<_, SnapshotMessage, _>(tag_name, stack, |name, stack, obj| {
match name {
"Marker" => {
obj.marker = Some(StringDeserializer::deserialize("Marker", stack)?);
}
"Snapshots" => {
obj.snapshots
.get_or_insert(vec![])
.extend(SnapshotListDeserializer::deserialize("Snapshots", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct SnapshotSchedule {
pub associated_cluster_count: Option<i64>,
pub associated_clusters: Option<Vec<ClusterAssociatedToSchedule>>,
pub next_invocations: Option<Vec<String>>,
pub schedule_definitions: Option<Vec<String>>,
pub schedule_description: Option<String>,
pub schedule_identifier: Option<String>,
pub tags: Option<Vec<Tag>>,
}
#[allow(dead_code)]
struct SnapshotScheduleDeserializer;
impl SnapshotScheduleDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<SnapshotSchedule, XmlParseError> {
deserialize_elements::<_, SnapshotSchedule, _>(tag_name, stack, |name, stack, obj| {
match name {
"AssociatedClusterCount" => {
obj.associated_cluster_count = Some(IntegerOptionalDeserializer::deserialize(
"AssociatedClusterCount",
stack,
)?);
}
"AssociatedClusters" => {
obj.associated_clusters.get_or_insert(vec![]).extend(
AssociatedClusterListDeserializer::deserialize(
"AssociatedClusters",
stack,
)?,
);
}
"NextInvocations" => {
obj.next_invocations.get_or_insert(vec![]).extend(
ScheduledSnapshotTimeListDeserializer::deserialize(
"NextInvocations",
stack,
)?,
);
}
"ScheduleDefinitions" => {
obj.schedule_definitions.get_or_insert(vec![]).extend(
ScheduleDefinitionListDeserializer::deserialize(
"ScheduleDefinitions",
stack,
)?,
);
}
"ScheduleDescription" => {
obj.schedule_description = Some(StringDeserializer::deserialize(
"ScheduleDescription",
stack,
)?);
}
"ScheduleIdentifier" => {
obj.schedule_identifier = Some(StringDeserializer::deserialize(
"ScheduleIdentifier",
stack,
)?);
}
"Tags" => {
obj.tags
.get_or_insert(vec![])
.extend(TagListDeserializer::deserialize("Tags", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[allow(dead_code)]
struct SnapshotScheduleListDeserializer;
impl SnapshotScheduleListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<SnapshotSchedule>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "SnapshotSchedule" {
obj.push(SnapshotScheduleDeserializer::deserialize(
"SnapshotSchedule",
stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct SnapshotSortingEntity {
pub attribute: String,
pub sort_order: Option<String>,
}
struct SnapshotSortingEntitySerializer;
impl SnapshotSortingEntitySerializer {
fn serialize(params: &mut Params, name: &str, obj: &SnapshotSortingEntity) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(&format!("{}{}", prefix, "Attribute"), &obj.attribute);
if let Some(ref field_value) = obj.sort_order {
params.put(&format!("{}{}", prefix, "SortOrder"), &field_value);
}
}
}
struct SnapshotSortingEntityListSerializer;
impl SnapshotSortingEntityListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<SnapshotSortingEntity>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.member.{}", name, index + 1);
SnapshotSortingEntitySerializer::serialize(params, &key, obj);
}
}
}
#[allow(dead_code)]
struct SourceIdsListDeserializer;
impl SourceIdsListDeserializer {
#[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 == "SourceId" {
obj.push(StringDeserializer::deserialize("SourceId", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct SourceIdsListSerializer;
impl SourceIdsListSerializer {
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 SourceTypeDeserializer;
impl SourceTypeDeserializer {
#[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 StringDeserializer;
impl StringDeserializer {
#[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 Subnet {
pub subnet_availability_zone: Option<AvailabilityZone>,
pub subnet_identifier: Option<String>,
pub subnet_status: Option<String>,
}
#[allow(dead_code)]
struct SubnetDeserializer;
impl SubnetDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<Subnet, XmlParseError> {
deserialize_elements::<_, Subnet, _>(tag_name, stack, |name, stack, obj| {
match name {
"SubnetAvailabilityZone" => {
obj.subnet_availability_zone = Some(AvailabilityZoneDeserializer::deserialize(
"SubnetAvailabilityZone",
stack,
)?);
}
"SubnetIdentifier" => {
obj.subnet_identifier =
Some(StringDeserializer::deserialize("SubnetIdentifier", stack)?);
}
"SubnetStatus" => {
obj.subnet_status =
Some(StringDeserializer::deserialize("SubnetStatus", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct SubnetIdentifierListSerializer;
impl SubnetIdentifierListSerializer {
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 SubnetListDeserializer;
impl SubnetListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<Subnet>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "Subnet" {
obj.push(SubnetDeserializer::deserialize("Subnet", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct SupportedOperation {
pub operation_name: Option<String>,
}
#[allow(dead_code)]
struct SupportedOperationDeserializer;
impl SupportedOperationDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<SupportedOperation, XmlParseError> {
deserialize_elements::<_, SupportedOperation, _>(tag_name, stack, |name, stack, obj| {
match name {
"OperationName" => {
obj.operation_name =
Some(StringDeserializer::deserialize("OperationName", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[allow(dead_code)]
struct SupportedOperationListDeserializer;
impl SupportedOperationListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<SupportedOperation>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "SupportedOperation" {
obj.push(SupportedOperationDeserializer::deserialize(
"SupportedOperation",
stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct SupportedPlatform {
pub name: Option<String>,
}
#[allow(dead_code)]
struct SupportedPlatformDeserializer;
impl SupportedPlatformDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<SupportedPlatform, XmlParseError> {
deserialize_elements::<_, SupportedPlatform, _>(tag_name, stack, |name, stack, obj| {
match name {
"Name" => {
obj.name = Some(StringDeserializer::deserialize("Name", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[allow(dead_code)]
struct SupportedPlatformsListDeserializer;
impl SupportedPlatformsListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<SupportedPlatform>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "SupportedPlatform" {
obj.push(SupportedPlatformDeserializer::deserialize(
"SupportedPlatform",
stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[allow(dead_code)]
struct TStampDeserializer;
impl TStampDeserializer {
#[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 TableRestoreStatus {
pub cluster_identifier: Option<String>,
pub message: Option<String>,
pub new_table_name: Option<String>,
pub progress_in_mega_bytes: Option<i64>,
pub request_time: Option<String>,
pub snapshot_identifier: Option<String>,
pub source_database_name: Option<String>,
pub source_schema_name: Option<String>,
pub source_table_name: Option<String>,
pub status: Option<String>,
pub table_restore_request_id: Option<String>,
pub target_database_name: Option<String>,
pub target_schema_name: Option<String>,
pub total_data_in_mega_bytes: Option<i64>,
}
#[allow(dead_code)]
struct TableRestoreStatusDeserializer;
impl TableRestoreStatusDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<TableRestoreStatus, XmlParseError> {
deserialize_elements::<_, TableRestoreStatus, _>(tag_name, stack, |name, stack, obj| {
match name {
"ClusterIdentifier" => {
obj.cluster_identifier =
Some(StringDeserializer::deserialize("ClusterIdentifier", stack)?);
}
"Message" => {
obj.message = Some(StringDeserializer::deserialize("Message", stack)?);
}
"NewTableName" => {
obj.new_table_name =
Some(StringDeserializer::deserialize("NewTableName", stack)?);
}
"ProgressInMegaBytes" => {
obj.progress_in_mega_bytes = Some(LongOptionalDeserializer::deserialize(
"ProgressInMegaBytes",
stack,
)?);
}
"RequestTime" => {
obj.request_time = Some(TStampDeserializer::deserialize("RequestTime", stack)?);
}
"SnapshotIdentifier" => {
obj.snapshot_identifier = Some(StringDeserializer::deserialize(
"SnapshotIdentifier",
stack,
)?);
}
"SourceDatabaseName" => {
obj.source_database_name = Some(StringDeserializer::deserialize(
"SourceDatabaseName",
stack,
)?);
}
"SourceSchemaName" => {
obj.source_schema_name =
Some(StringDeserializer::deserialize("SourceSchemaName", stack)?);
}
"SourceTableName" => {
obj.source_table_name =
Some(StringDeserializer::deserialize("SourceTableName", stack)?);
}
"Status" => {
obj.status = Some(TableRestoreStatusTypeDeserializer::deserialize(
"Status", stack,
)?);
}
"TableRestoreRequestId" => {
obj.table_restore_request_id = Some(StringDeserializer::deserialize(
"TableRestoreRequestId",
stack,
)?);
}
"TargetDatabaseName" => {
obj.target_database_name = Some(StringDeserializer::deserialize(
"TargetDatabaseName",
stack,
)?);
}
"TargetSchemaName" => {
obj.target_schema_name =
Some(StringDeserializer::deserialize("TargetSchemaName", stack)?);
}
"TotalDataInMegaBytes" => {
obj.total_data_in_mega_bytes = Some(LongOptionalDeserializer::deserialize(
"TotalDataInMegaBytes",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[allow(dead_code)]
struct TableRestoreStatusListDeserializer;
impl TableRestoreStatusListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<TableRestoreStatus>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "TableRestoreStatus" {
obj.push(TableRestoreStatusDeserializer::deserialize(
"TableRestoreStatus",
stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct TableRestoreStatusMessage {
pub marker: Option<String>,
pub table_restore_status_details: Option<Vec<TableRestoreStatus>>,
}
#[allow(dead_code)]
struct TableRestoreStatusMessageDeserializer;
impl TableRestoreStatusMessageDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<TableRestoreStatusMessage, XmlParseError> {
deserialize_elements::<_, TableRestoreStatusMessage, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"Marker" => {
obj.marker = Some(StringDeserializer::deserialize("Marker", stack)?);
}
"TableRestoreStatusDetails" => {
obj.table_restore_status_details
.get_or_insert(vec![])
.extend(TableRestoreStatusListDeserializer::deserialize(
"TableRestoreStatusDetails",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[allow(dead_code)]
struct TableRestoreStatusTypeDeserializer;
impl TableRestoreStatusTypeDeserializer {
#[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: Option<String>,
pub value: Option<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 = Some(StringDeserializer::deserialize("Key", stack)?);
}
"Value" => {
obj.value = Some(StringDeserializer::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(".");
}
if let Some(ref field_value) = obj.key {
params.put(&format!("{}{}", prefix, "Key"), &field_value);
}
if let Some(ref field_value) = obj.value {
params.put(&format!("{}{}", prefix, "Value"), &field_value);
}
}
}
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 == "Tag" {
obj.push(TagDeserializer::deserialize("Tag", 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);
}
}
}
struct TagValueListSerializer;
impl TagValueListSerializer {
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 TaggedResource {
pub resource_name: Option<String>,
pub resource_type: Option<String>,
pub tag: Option<Tag>,
}
#[allow(dead_code)]
struct TaggedResourceDeserializer;
impl TaggedResourceDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<TaggedResource, XmlParseError> {
deserialize_elements::<_, TaggedResource, _>(tag_name, stack, |name, stack, obj| {
match name {
"ResourceName" => {
obj.resource_name =
Some(StringDeserializer::deserialize("ResourceName", stack)?);
}
"ResourceType" => {
obj.resource_type =
Some(StringDeserializer::deserialize("ResourceType", stack)?);
}
"Tag" => {
obj.tag = Some(TagDeserializer::deserialize("Tag", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[allow(dead_code)]
struct TaggedResourceListDeserializer;
impl TaggedResourceListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<TaggedResource>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "TaggedResource" {
obj.push(TaggedResourceDeserializer::deserialize(
"TaggedResource",
stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct TaggedResourceListMessage {
pub marker: Option<String>,
pub tagged_resources: Option<Vec<TaggedResource>>,
}
#[allow(dead_code)]
struct TaggedResourceListMessageDeserializer;
impl TaggedResourceListMessageDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<TaggedResourceListMessage, XmlParseError> {
deserialize_elements::<_, TaggedResourceListMessage, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"Marker" => {
obj.marker = Some(StringDeserializer::deserialize("Marker", stack)?);
}
"TaggedResources" => {
obj.tagged_resources.get_or_insert(vec![]).extend(
TaggedResourceListDeserializer::deserialize("TaggedResources", stack)?,
);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[allow(dead_code)]
struct TrackListDeserializer;
impl TrackListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<MaintenanceTrack>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "MaintenanceTrack" {
obj.push(MaintenanceTrackDeserializer::deserialize(
"MaintenanceTrack",
stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct TrackListMessage {
pub maintenance_tracks: Option<Vec<MaintenanceTrack>>,
pub marker: Option<String>,
}
#[allow(dead_code)]
struct TrackListMessageDeserializer;
impl TrackListMessageDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<TrackListMessage, XmlParseError> {
deserialize_elements::<_, TrackListMessage, _>(tag_name, stack, |name, stack, obj| {
match name {
"MaintenanceTracks" => {
obj.maintenance_tracks.get_or_insert(vec![]).extend(
TrackListDeserializer::deserialize("MaintenanceTracks", stack)?,
);
}
"Marker" => {
obj.marker = Some(StringDeserializer::deserialize("Marker", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct UpdateTarget {
pub database_version: Option<String>,
pub maintenance_track_name: Option<String>,
pub supported_operations: Option<Vec<SupportedOperation>>,
}
#[allow(dead_code)]
struct UpdateTargetDeserializer;
impl UpdateTargetDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<UpdateTarget, XmlParseError> {
deserialize_elements::<_, UpdateTarget, _>(tag_name, stack, |name, stack, obj| {
match name {
"DatabaseVersion" => {
obj.database_version =
Some(StringDeserializer::deserialize("DatabaseVersion", stack)?);
}
"MaintenanceTrackName" => {
obj.maintenance_track_name = Some(StringDeserializer::deserialize(
"MaintenanceTrackName",
stack,
)?);
}
"SupportedOperations" => {
obj.supported_operations.get_or_insert(vec![]).extend(
SupportedOperationListDeserializer::deserialize(
"SupportedOperations",
stack,
)?,
);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct UsageLimit {
pub amount: Option<i64>,
pub breach_action: Option<String>,
pub cluster_identifier: Option<String>,
pub feature_type: Option<String>,
pub limit_type: Option<String>,
pub period: Option<String>,
pub tags: Option<Vec<Tag>>,
pub usage_limit_id: Option<String>,
}
#[allow(dead_code)]
struct UsageLimitDeserializer;
impl UsageLimitDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<UsageLimit, XmlParseError> {
deserialize_elements::<_, UsageLimit, _>(tag_name, stack, |name, stack, obj| {
match name {
"Amount" => {
obj.amount = Some(LongDeserializer::deserialize("Amount", stack)?);
}
"BreachAction" => {
obj.breach_action = Some(UsageLimitBreachActionDeserializer::deserialize(
"BreachAction",
stack,
)?);
}
"ClusterIdentifier" => {
obj.cluster_identifier =
Some(StringDeserializer::deserialize("ClusterIdentifier", stack)?);
}
"FeatureType" => {
obj.feature_type = Some(UsageLimitFeatureTypeDeserializer::deserialize(
"FeatureType",
stack,
)?);
}
"LimitType" => {
obj.limit_type = Some(UsageLimitLimitTypeDeserializer::deserialize(
"LimitType",
stack,
)?);
}
"Period" => {
obj.period = Some(UsageLimitPeriodDeserializer::deserialize("Period", stack)?);
}
"Tags" => {
obj.tags
.get_or_insert(vec![])
.extend(TagListDeserializer::deserialize("Tags", stack)?);
}
"UsageLimitId" => {
obj.usage_limit_id =
Some(StringDeserializer::deserialize("UsageLimitId", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[allow(dead_code)]
struct UsageLimitBreachActionDeserializer;
impl UsageLimitBreachActionDeserializer {
#[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 UsageLimitFeatureTypeDeserializer;
impl UsageLimitFeatureTypeDeserializer {
#[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 UsageLimitLimitTypeDeserializer;
impl UsageLimitLimitTypeDeserializer {
#[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 UsageLimitList {
pub marker: Option<String>,
pub usage_limits: Option<Vec<UsageLimit>>,
}
#[allow(dead_code)]
struct UsageLimitListDeserializer;
impl UsageLimitListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<UsageLimitList, XmlParseError> {
deserialize_elements::<_, UsageLimitList, _>(tag_name, stack, |name, stack, obj| {
match name {
"Marker" => {
obj.marker = Some(StringDeserializer::deserialize("Marker", stack)?);
}
"UsageLimits" => {
obj.usage_limits
.get_or_insert(vec![])
.extend(UsageLimitsDeserializer::deserialize("UsageLimits", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[allow(dead_code)]
struct UsageLimitPeriodDeserializer;
impl UsageLimitPeriodDeserializer {
#[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 UsageLimitsDeserializer;
impl UsageLimitsDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<UsageLimit>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "member" {
obj.push(UsageLimitDeserializer::deserialize("member", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct ValueStringListSerializer;
impl ValueStringListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.member.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
struct VpcSecurityGroupIdListSerializer;
impl VpcSecurityGroupIdListSerializer {
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 VpcSecurityGroupMembership {
pub status: Option<String>,
pub vpc_security_group_id: Option<String>,
}
#[allow(dead_code)]
struct VpcSecurityGroupMembershipDeserializer;
impl VpcSecurityGroupMembershipDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<VpcSecurityGroupMembership, XmlParseError> {
deserialize_elements::<_, VpcSecurityGroupMembership, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"Status" => {
obj.status = Some(StringDeserializer::deserialize("Status", stack)?);
}
"VpcSecurityGroupId" => {
obj.vpc_security_group_id = Some(StringDeserializer::deserialize(
"VpcSecurityGroupId",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[allow(dead_code)]
struct VpcSecurityGroupMembershipListDeserializer;
impl VpcSecurityGroupMembershipListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<VpcSecurityGroupMembership>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "VpcSecurityGroup" {
obj.push(VpcSecurityGroupMembershipDeserializer::deserialize(
"VpcSecurityGroup",
stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Debug, PartialEq)]
pub enum AcceptReservedNodeExchangeError {
DependentServiceUnavailableFault(String),
InvalidReservedNodeStateFault(String),
ReservedNodeAlreadyExistsFault(String),
ReservedNodeAlreadyMigratedFault(String),
ReservedNodeNotFoundFault(String),
ReservedNodeOfferingNotFoundFault(String),
UnsupportedOperationFault(String),
}
impl AcceptReservedNodeExchangeError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<AcceptReservedNodeExchangeError> {
{
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[..] {
"DependentServiceUnavailableFault" => {
return RusotoError::Service(
AcceptReservedNodeExchangeError::DependentServiceUnavailableFault(
parsed_error.message,
),
)
}
"InvalidReservedNodeState" => {
return RusotoError::Service(
AcceptReservedNodeExchangeError::InvalidReservedNodeStateFault(
parsed_error.message,
),
)
}
"ReservedNodeAlreadyExists" => {
return RusotoError::Service(
AcceptReservedNodeExchangeError::ReservedNodeAlreadyExistsFault(
parsed_error.message,
),
)
}
"ReservedNodeAlreadyMigrated" => {
return RusotoError::Service(
AcceptReservedNodeExchangeError::ReservedNodeAlreadyMigratedFault(
parsed_error.message,
),
)
}
"ReservedNodeNotFound" => {
return RusotoError::Service(
AcceptReservedNodeExchangeError::ReservedNodeNotFoundFault(
parsed_error.message,
),
)
}
"ReservedNodeOfferingNotFound" => {
return RusotoError::Service(
AcceptReservedNodeExchangeError::ReservedNodeOfferingNotFoundFault(
parsed_error.message,
),
)
}
"UnsupportedOperation" => {
return RusotoError::Service(
AcceptReservedNodeExchangeError::UnsupportedOperationFault(
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 AcceptReservedNodeExchangeError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AcceptReservedNodeExchangeError::DependentServiceUnavailableFault(ref cause) => {
write!(f, "{}", cause)
}
AcceptReservedNodeExchangeError::InvalidReservedNodeStateFault(ref cause) => {
write!(f, "{}", cause)
}
AcceptReservedNodeExchangeError::ReservedNodeAlreadyExistsFault(ref cause) => {
write!(f, "{}", cause)
}
AcceptReservedNodeExchangeError::ReservedNodeAlreadyMigratedFault(ref cause) => {
write!(f, "{}", cause)
}
AcceptReservedNodeExchangeError::ReservedNodeNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
AcceptReservedNodeExchangeError::ReservedNodeOfferingNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
AcceptReservedNodeExchangeError::UnsupportedOperationFault(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for AcceptReservedNodeExchangeError {}
#[derive(Debug, PartialEq)]
pub enum AuthorizeClusterSecurityGroupIngressError {
AuthorizationAlreadyExistsFault(String),
AuthorizationQuotaExceededFault(String),
ClusterSecurityGroupNotFoundFault(String),
InvalidClusterSecurityGroupStateFault(String),
}
impl AuthorizeClusterSecurityGroupIngressError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<AuthorizeClusterSecurityGroupIngressError> {
{
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[..] {
"AuthorizationAlreadyExists" => return RusotoError::Service(AuthorizeClusterSecurityGroupIngressError::AuthorizationAlreadyExistsFault(parsed_error.message)),"AuthorizationQuotaExceeded" => return RusotoError::Service(AuthorizeClusterSecurityGroupIngressError::AuthorizationQuotaExceededFault(parsed_error.message)),"ClusterSecurityGroupNotFound" => return RusotoError::Service(AuthorizeClusterSecurityGroupIngressError::ClusterSecurityGroupNotFoundFault(parsed_error.message)),"InvalidClusterSecurityGroupState" => return RusotoError::Service(AuthorizeClusterSecurityGroupIngressError::InvalidClusterSecurityGroupStateFault(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 AuthorizeClusterSecurityGroupIngressError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AuthorizeClusterSecurityGroupIngressError::AuthorizationAlreadyExistsFault(
ref cause,
) => write!(f, "{}", cause),
AuthorizeClusterSecurityGroupIngressError::AuthorizationQuotaExceededFault(
ref cause,
) => write!(f, "{}", cause),
AuthorizeClusterSecurityGroupIngressError::ClusterSecurityGroupNotFoundFault(
ref cause,
) => write!(f, "{}", cause),
AuthorizeClusterSecurityGroupIngressError::InvalidClusterSecurityGroupStateFault(
ref cause,
) => write!(f, "{}", cause),
}
}
}
impl Error for AuthorizeClusterSecurityGroupIngressError {}
#[derive(Debug, PartialEq)]
pub enum AuthorizeSnapshotAccessError {
AuthorizationAlreadyExistsFault(String),
AuthorizationQuotaExceededFault(String),
ClusterSnapshotNotFoundFault(String),
DependentServiceRequestThrottlingFault(String),
InvalidClusterSnapshotStateFault(String),
LimitExceededFault(String),
}
impl AuthorizeSnapshotAccessError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<AuthorizeSnapshotAccessError> {
{
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[..] {
"AuthorizationAlreadyExists" => {
return RusotoError::Service(
AuthorizeSnapshotAccessError::AuthorizationAlreadyExistsFault(
parsed_error.message,
),
)
}
"AuthorizationQuotaExceeded" => {
return RusotoError::Service(
AuthorizeSnapshotAccessError::AuthorizationQuotaExceededFault(
parsed_error.message,
),
)
}
"ClusterSnapshotNotFound" => {
return RusotoError::Service(
AuthorizeSnapshotAccessError::ClusterSnapshotNotFoundFault(
parsed_error.message,
),
)
}
"DependentServiceRequestThrottlingFault" => {
return RusotoError::Service(
AuthorizeSnapshotAccessError::DependentServiceRequestThrottlingFault(
parsed_error.message,
),
)
}
"InvalidClusterSnapshotState" => {
return RusotoError::Service(
AuthorizeSnapshotAccessError::InvalidClusterSnapshotStateFault(
parsed_error.message,
),
)
}
"LimitExceededFault" => {
return RusotoError::Service(
AuthorizeSnapshotAccessError::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 AuthorizeSnapshotAccessError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AuthorizeSnapshotAccessError::AuthorizationAlreadyExistsFault(ref cause) => {
write!(f, "{}", cause)
}
AuthorizeSnapshotAccessError::AuthorizationQuotaExceededFault(ref cause) => {
write!(f, "{}", cause)
}
AuthorizeSnapshotAccessError::ClusterSnapshotNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
AuthorizeSnapshotAccessError::DependentServiceRequestThrottlingFault(ref cause) => {
write!(f, "{}", cause)
}
AuthorizeSnapshotAccessError::InvalidClusterSnapshotStateFault(ref cause) => {
write!(f, "{}", cause)
}
AuthorizeSnapshotAccessError::LimitExceededFault(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for AuthorizeSnapshotAccessError {}
#[derive(Debug, PartialEq)]
pub enum BatchDeleteClusterSnapshotsError {
BatchDeleteRequestSizeExceededFault(String),
}
impl BatchDeleteClusterSnapshotsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<BatchDeleteClusterSnapshotsError> {
{
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[..] {
"BatchDeleteRequestSizeExceeded" => {
return RusotoError::Service(
BatchDeleteClusterSnapshotsError::BatchDeleteRequestSizeExceededFault(
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 BatchDeleteClusterSnapshotsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
BatchDeleteClusterSnapshotsError::BatchDeleteRequestSizeExceededFault(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for BatchDeleteClusterSnapshotsError {}
#[derive(Debug, PartialEq)]
pub enum BatchModifyClusterSnapshotsError {
BatchModifyClusterSnapshotsLimitExceededFault(String),
InvalidRetentionPeriodFault(String),
}
impl BatchModifyClusterSnapshotsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<BatchModifyClusterSnapshotsError> {
{
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[..] {
"BatchModifyClusterSnapshotsLimitExceededFault" => return RusotoError::Service(BatchModifyClusterSnapshotsError::BatchModifyClusterSnapshotsLimitExceededFault(parsed_error.message)),"InvalidRetentionPeriodFault" => return RusotoError::Service(BatchModifyClusterSnapshotsError::InvalidRetentionPeriodFault(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 BatchModifyClusterSnapshotsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
BatchModifyClusterSnapshotsError::BatchModifyClusterSnapshotsLimitExceededFault(
ref cause,
) => write!(f, "{}", cause),
BatchModifyClusterSnapshotsError::InvalidRetentionPeriodFault(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for BatchModifyClusterSnapshotsError {}
#[derive(Debug, PartialEq)]
pub enum CancelResizeError {
ClusterNotFoundFault(String),
InvalidClusterStateFault(String),
ResizeNotFoundFault(String),
UnsupportedOperationFault(String),
}
impl CancelResizeError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CancelResizeError> {
{
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[..] {
"ClusterNotFound" => {
return RusotoError::Service(CancelResizeError::ClusterNotFoundFault(
parsed_error.message,
))
}
"InvalidClusterState" => {
return RusotoError::Service(CancelResizeError::InvalidClusterStateFault(
parsed_error.message,
))
}
"ResizeNotFound" => {
return RusotoError::Service(CancelResizeError::ResizeNotFoundFault(
parsed_error.message,
))
}
"UnsupportedOperation" => {
return RusotoError::Service(CancelResizeError::UnsupportedOperationFault(
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 CancelResizeError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CancelResizeError::ClusterNotFoundFault(ref cause) => write!(f, "{}", cause),
CancelResizeError::InvalidClusterStateFault(ref cause) => write!(f, "{}", cause),
CancelResizeError::ResizeNotFoundFault(ref cause) => write!(f, "{}", cause),
CancelResizeError::UnsupportedOperationFault(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CancelResizeError {}
#[derive(Debug, PartialEq)]
pub enum CopyClusterSnapshotError {
ClusterSnapshotAlreadyExistsFault(String),
ClusterSnapshotNotFoundFault(String),
ClusterSnapshotQuotaExceededFault(String),
InvalidClusterSnapshotStateFault(String),
InvalidRetentionPeriodFault(String),
}
impl CopyClusterSnapshotError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CopyClusterSnapshotError> {
{
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[..] {
"ClusterSnapshotAlreadyExists" => {
return RusotoError::Service(
CopyClusterSnapshotError::ClusterSnapshotAlreadyExistsFault(
parsed_error.message,
),
)
}
"ClusterSnapshotNotFound" => {
return RusotoError::Service(
CopyClusterSnapshotError::ClusterSnapshotNotFoundFault(
parsed_error.message,
),
)
}
"ClusterSnapshotQuotaExceeded" => {
return RusotoError::Service(
CopyClusterSnapshotError::ClusterSnapshotQuotaExceededFault(
parsed_error.message,
),
)
}
"InvalidClusterSnapshotState" => {
return RusotoError::Service(
CopyClusterSnapshotError::InvalidClusterSnapshotStateFault(
parsed_error.message,
),
)
}
"InvalidRetentionPeriodFault" => {
return RusotoError::Service(
CopyClusterSnapshotError::InvalidRetentionPeriodFault(
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 CopyClusterSnapshotError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CopyClusterSnapshotError::ClusterSnapshotAlreadyExistsFault(ref cause) => {
write!(f, "{}", cause)
}
CopyClusterSnapshotError::ClusterSnapshotNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
CopyClusterSnapshotError::ClusterSnapshotQuotaExceededFault(ref cause) => {
write!(f, "{}", cause)
}
CopyClusterSnapshotError::InvalidClusterSnapshotStateFault(ref cause) => {
write!(f, "{}", cause)
}
CopyClusterSnapshotError::InvalidRetentionPeriodFault(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for CopyClusterSnapshotError {}
#[derive(Debug, PartialEq)]
pub enum CreateClusterError {
ClusterAlreadyExistsFault(String),
ClusterParameterGroupNotFoundFault(String),
ClusterQuotaExceededFault(String),
ClusterSecurityGroupNotFoundFault(String),
ClusterSubnetGroupNotFoundFault(String),
DependentServiceRequestThrottlingFault(String),
HsmClientCertificateNotFoundFault(String),
HsmConfigurationNotFoundFault(String),
InsufficientClusterCapacityFault(String),
InvalidClusterSubnetGroupStateFault(String),
InvalidClusterTrackFault(String),
InvalidElasticIpFault(String),
InvalidRetentionPeriodFault(String),
InvalidSubnet(String),
InvalidTagFault(String),
InvalidVPCNetworkStateFault(String),
LimitExceededFault(String),
NumberOfNodesPerClusterLimitExceededFault(String),
NumberOfNodesQuotaExceededFault(String),
SnapshotScheduleNotFoundFault(String),
TagLimitExceededFault(String),
UnauthorizedOperation(String),
}
impl CreateClusterError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateClusterError> {
{
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[..] {
"ClusterAlreadyExists" => {
return RusotoError::Service(CreateClusterError::ClusterAlreadyExistsFault(
parsed_error.message,
))
}
"ClusterParameterGroupNotFound" => {
return RusotoError::Service(
CreateClusterError::ClusterParameterGroupNotFoundFault(
parsed_error.message,
),
)
}
"ClusterQuotaExceeded" => {
return RusotoError::Service(CreateClusterError::ClusterQuotaExceededFault(
parsed_error.message,
))
}
"ClusterSecurityGroupNotFound" => {
return RusotoError::Service(
CreateClusterError::ClusterSecurityGroupNotFoundFault(
parsed_error.message,
),
)
}
"ClusterSubnetGroupNotFoundFault" => {
return RusotoError::Service(
CreateClusterError::ClusterSubnetGroupNotFoundFault(
parsed_error.message,
),
)
}
"DependentServiceRequestThrottlingFault" => {
return RusotoError::Service(
CreateClusterError::DependentServiceRequestThrottlingFault(
parsed_error.message,
),
)
}
"HsmClientCertificateNotFoundFault" => {
return RusotoError::Service(
CreateClusterError::HsmClientCertificateNotFoundFault(
parsed_error.message,
),
)
}
"HsmConfigurationNotFoundFault" => {
return RusotoError::Service(
CreateClusterError::HsmConfigurationNotFoundFault(parsed_error.message),
)
}
"InsufficientClusterCapacity" => {
return RusotoError::Service(
CreateClusterError::InsufficientClusterCapacityFault(
parsed_error.message,
),
)
}
"InvalidClusterSubnetGroupStateFault" => {
return RusotoError::Service(
CreateClusterError::InvalidClusterSubnetGroupStateFault(
parsed_error.message,
),
)
}
"InvalidClusterTrack" => {
return RusotoError::Service(CreateClusterError::InvalidClusterTrackFault(
parsed_error.message,
))
}
"InvalidElasticIpFault" => {
return RusotoError::Service(CreateClusterError::InvalidElasticIpFault(
parsed_error.message,
))
}
"InvalidRetentionPeriodFault" => {
return RusotoError::Service(
CreateClusterError::InvalidRetentionPeriodFault(parsed_error.message),
)
}
"InvalidSubnet" => {
return RusotoError::Service(CreateClusterError::InvalidSubnet(
parsed_error.message,
))
}
"InvalidTagFault" => {
return RusotoError::Service(CreateClusterError::InvalidTagFault(
parsed_error.message,
))
}
"InvalidVPCNetworkStateFault" => {
return RusotoError::Service(
CreateClusterError::InvalidVPCNetworkStateFault(parsed_error.message),
)
}
"LimitExceededFault" => {
return RusotoError::Service(CreateClusterError::LimitExceededFault(
parsed_error.message,
))
}
"NumberOfNodesPerClusterLimitExceeded" => {
return RusotoError::Service(
CreateClusterError::NumberOfNodesPerClusterLimitExceededFault(
parsed_error.message,
),
)
}
"NumberOfNodesQuotaExceeded" => {
return RusotoError::Service(
CreateClusterError::NumberOfNodesQuotaExceededFault(
parsed_error.message,
),
)
}
"SnapshotScheduleNotFound" => {
return RusotoError::Service(
CreateClusterError::SnapshotScheduleNotFoundFault(parsed_error.message),
)
}
"TagLimitExceededFault" => {
return RusotoError::Service(CreateClusterError::TagLimitExceededFault(
parsed_error.message,
))
}
"UnauthorizedOperation" => {
return RusotoError::Service(CreateClusterError::UnauthorizedOperation(
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 CreateClusterError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateClusterError::ClusterAlreadyExistsFault(ref cause) => write!(f, "{}", cause),
CreateClusterError::ClusterParameterGroupNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
CreateClusterError::ClusterQuotaExceededFault(ref cause) => write!(f, "{}", cause),
CreateClusterError::ClusterSecurityGroupNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
CreateClusterError::ClusterSubnetGroupNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
CreateClusterError::DependentServiceRequestThrottlingFault(ref cause) => {
write!(f, "{}", cause)
}
CreateClusterError::HsmClientCertificateNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
CreateClusterError::HsmConfigurationNotFoundFault(ref cause) => write!(f, "{}", cause),
CreateClusterError::InsufficientClusterCapacityFault(ref cause) => {
write!(f, "{}", cause)
}
CreateClusterError::InvalidClusterSubnetGroupStateFault(ref cause) => {
write!(f, "{}", cause)
}
CreateClusterError::InvalidClusterTrackFault(ref cause) => write!(f, "{}", cause),
CreateClusterError::InvalidElasticIpFault(ref cause) => write!(f, "{}", cause),
CreateClusterError::InvalidRetentionPeriodFault(ref cause) => write!(f, "{}", cause),
CreateClusterError::InvalidSubnet(ref cause) => write!(f, "{}", cause),
CreateClusterError::InvalidTagFault(ref cause) => write!(f, "{}", cause),
CreateClusterError::InvalidVPCNetworkStateFault(ref cause) => write!(f, "{}", cause),
CreateClusterError::LimitExceededFault(ref cause) => write!(f, "{}", cause),
CreateClusterError::NumberOfNodesPerClusterLimitExceededFault(ref cause) => {
write!(f, "{}", cause)
}
CreateClusterError::NumberOfNodesQuotaExceededFault(ref cause) => {
write!(f, "{}", cause)
}
CreateClusterError::SnapshotScheduleNotFoundFault(ref cause) => write!(f, "{}", cause),
CreateClusterError::TagLimitExceededFault(ref cause) => write!(f, "{}", cause),
CreateClusterError::UnauthorizedOperation(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateClusterError {}
#[derive(Debug, PartialEq)]
pub enum CreateClusterParameterGroupError {
ClusterParameterGroupAlreadyExistsFault(String),
ClusterParameterGroupQuotaExceededFault(String),
InvalidTagFault(String),
TagLimitExceededFault(String),
}
impl CreateClusterParameterGroupError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<CreateClusterParameterGroupError> {
{
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[..] {
"ClusterParameterGroupAlreadyExists" => return RusotoError::Service(
CreateClusterParameterGroupError::ClusterParameterGroupAlreadyExistsFault(
parsed_error.message,
),
),
"ClusterParameterGroupQuotaExceeded" => return RusotoError::Service(
CreateClusterParameterGroupError::ClusterParameterGroupQuotaExceededFault(
parsed_error.message,
),
),
"InvalidTagFault" => {
return RusotoError::Service(
CreateClusterParameterGroupError::InvalidTagFault(parsed_error.message),
)
}
"TagLimitExceededFault" => {
return RusotoError::Service(
CreateClusterParameterGroupError::TagLimitExceededFault(
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 CreateClusterParameterGroupError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateClusterParameterGroupError::ClusterParameterGroupAlreadyExistsFault(
ref cause,
) => write!(f, "{}", cause),
CreateClusterParameterGroupError::ClusterParameterGroupQuotaExceededFault(
ref cause,
) => write!(f, "{}", cause),
CreateClusterParameterGroupError::InvalidTagFault(ref cause) => write!(f, "{}", cause),
CreateClusterParameterGroupError::TagLimitExceededFault(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for CreateClusterParameterGroupError {}
#[derive(Debug, PartialEq)]
pub enum CreateClusterSecurityGroupError {
ClusterSecurityGroupAlreadyExistsFault(String),
ClusterSecurityGroupQuotaExceededFault(String),
InvalidTagFault(String),
TagLimitExceededFault(String),
}
impl CreateClusterSecurityGroupError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<CreateClusterSecurityGroupError> {
{
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[..] {
"ClusterSecurityGroupAlreadyExists" => {
return RusotoError::Service(
CreateClusterSecurityGroupError::ClusterSecurityGroupAlreadyExistsFault(
parsed_error.message,
),
)
}
"QuotaExceeded.ClusterSecurityGroup" => {
return RusotoError::Service(
CreateClusterSecurityGroupError::ClusterSecurityGroupQuotaExceededFault(
parsed_error.message,
),
)
}
"InvalidTagFault" => {
return RusotoError::Service(
CreateClusterSecurityGroupError::InvalidTagFault(parsed_error.message),
)
}
"TagLimitExceededFault" => {
return RusotoError::Service(
CreateClusterSecurityGroupError::TagLimitExceededFault(
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 CreateClusterSecurityGroupError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateClusterSecurityGroupError::ClusterSecurityGroupAlreadyExistsFault(ref cause) => {
write!(f, "{}", cause)
}
CreateClusterSecurityGroupError::ClusterSecurityGroupQuotaExceededFault(ref cause) => {
write!(f, "{}", cause)
}
CreateClusterSecurityGroupError::InvalidTagFault(ref cause) => write!(f, "{}", cause),
CreateClusterSecurityGroupError::TagLimitExceededFault(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for CreateClusterSecurityGroupError {}
#[derive(Debug, PartialEq)]
pub enum CreateClusterSnapshotError {
ClusterNotFoundFault(String),
ClusterSnapshotAlreadyExistsFault(String),
ClusterSnapshotQuotaExceededFault(String),
InvalidClusterStateFault(String),
InvalidRetentionPeriodFault(String),
InvalidTagFault(String),
TagLimitExceededFault(String),
}
impl CreateClusterSnapshotError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateClusterSnapshotError> {
{
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[..] {
"ClusterNotFound" => {
return RusotoError::Service(
CreateClusterSnapshotError::ClusterNotFoundFault(parsed_error.message),
)
}
"ClusterSnapshotAlreadyExists" => {
return RusotoError::Service(
CreateClusterSnapshotError::ClusterSnapshotAlreadyExistsFault(
parsed_error.message,
),
)
}
"ClusterSnapshotQuotaExceeded" => {
return RusotoError::Service(
CreateClusterSnapshotError::ClusterSnapshotQuotaExceededFault(
parsed_error.message,
),
)
}
"InvalidClusterState" => {
return RusotoError::Service(
CreateClusterSnapshotError::InvalidClusterStateFault(
parsed_error.message,
),
)
}
"InvalidRetentionPeriodFault" => {
return RusotoError::Service(
CreateClusterSnapshotError::InvalidRetentionPeriodFault(
parsed_error.message,
),
)
}
"InvalidTagFault" => {
return RusotoError::Service(CreateClusterSnapshotError::InvalidTagFault(
parsed_error.message,
))
}
"TagLimitExceededFault" => {
return RusotoError::Service(
CreateClusterSnapshotError::TagLimitExceededFault(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 CreateClusterSnapshotError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateClusterSnapshotError::ClusterNotFoundFault(ref cause) => write!(f, "{}", cause),
CreateClusterSnapshotError::ClusterSnapshotAlreadyExistsFault(ref cause) => {
write!(f, "{}", cause)
}
CreateClusterSnapshotError::ClusterSnapshotQuotaExceededFault(ref cause) => {
write!(f, "{}", cause)
}
CreateClusterSnapshotError::InvalidClusterStateFault(ref cause) => {
write!(f, "{}", cause)
}
CreateClusterSnapshotError::InvalidRetentionPeriodFault(ref cause) => {
write!(f, "{}", cause)
}
CreateClusterSnapshotError::InvalidTagFault(ref cause) => write!(f, "{}", cause),
CreateClusterSnapshotError::TagLimitExceededFault(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateClusterSnapshotError {}
#[derive(Debug, PartialEq)]
pub enum CreateClusterSubnetGroupError {
ClusterSubnetGroupAlreadyExistsFault(String),
ClusterSubnetGroupQuotaExceededFault(String),
ClusterSubnetQuotaExceededFault(String),
DependentServiceRequestThrottlingFault(String),
InvalidSubnet(String),
InvalidTagFault(String),
TagLimitExceededFault(String),
UnauthorizedOperation(String),
}
impl CreateClusterSubnetGroupError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateClusterSubnetGroupError> {
{
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[..] {
"ClusterSubnetGroupAlreadyExists" => {
return RusotoError::Service(
CreateClusterSubnetGroupError::ClusterSubnetGroupAlreadyExistsFault(
parsed_error.message,
),
)
}
"ClusterSubnetGroupQuotaExceeded" => {
return RusotoError::Service(
CreateClusterSubnetGroupError::ClusterSubnetGroupQuotaExceededFault(
parsed_error.message,
),
)
}
"ClusterSubnetQuotaExceededFault" => {
return RusotoError::Service(
CreateClusterSubnetGroupError::ClusterSubnetQuotaExceededFault(
parsed_error.message,
),
)
}
"DependentServiceRequestThrottlingFault" => {
return RusotoError::Service(
CreateClusterSubnetGroupError::DependentServiceRequestThrottlingFault(
parsed_error.message,
),
)
}
"InvalidSubnet" => {
return RusotoError::Service(CreateClusterSubnetGroupError::InvalidSubnet(
parsed_error.message,
))
}
"InvalidTagFault" => {
return RusotoError::Service(
CreateClusterSubnetGroupError::InvalidTagFault(parsed_error.message),
)
}
"TagLimitExceededFault" => {
return RusotoError::Service(
CreateClusterSubnetGroupError::TagLimitExceededFault(
parsed_error.message,
),
)
}
"UnauthorizedOperation" => {
return RusotoError::Service(
CreateClusterSubnetGroupError::UnauthorizedOperation(
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 CreateClusterSubnetGroupError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateClusterSubnetGroupError::ClusterSubnetGroupAlreadyExistsFault(ref cause) => {
write!(f, "{}", cause)
}
CreateClusterSubnetGroupError::ClusterSubnetGroupQuotaExceededFault(ref cause) => {
write!(f, "{}", cause)
}
CreateClusterSubnetGroupError::ClusterSubnetQuotaExceededFault(ref cause) => {
write!(f, "{}", cause)
}
CreateClusterSubnetGroupError::DependentServiceRequestThrottlingFault(ref cause) => {
write!(f, "{}", cause)
}
CreateClusterSubnetGroupError::InvalidSubnet(ref cause) => write!(f, "{}", cause),
CreateClusterSubnetGroupError::InvalidTagFault(ref cause) => write!(f, "{}", cause),
CreateClusterSubnetGroupError::TagLimitExceededFault(ref cause) => {
write!(f, "{}", cause)
}
CreateClusterSubnetGroupError::UnauthorizedOperation(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for CreateClusterSubnetGroupError {}
#[derive(Debug, PartialEq)]
pub enum CreateEventSubscriptionError {
EventSubscriptionQuotaExceededFault(String),
InvalidTagFault(String),
SNSInvalidTopicFault(String),
SNSNoAuthorizationFault(String),
SNSTopicArnNotFoundFault(String),
SourceNotFoundFault(String),
SubscriptionAlreadyExistFault(String),
SubscriptionCategoryNotFoundFault(String),
SubscriptionEventIdNotFoundFault(String),
SubscriptionSeverityNotFoundFault(String),
TagLimitExceededFault(String),
}
impl CreateEventSubscriptionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateEventSubscriptionError> {
{
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[..] {
"EventSubscriptionQuotaExceeded" => {
return RusotoError::Service(
CreateEventSubscriptionError::EventSubscriptionQuotaExceededFault(
parsed_error.message,
),
)
}
"InvalidTagFault" => {
return RusotoError::Service(CreateEventSubscriptionError::InvalidTagFault(
parsed_error.message,
))
}
"SNSInvalidTopic" => {
return RusotoError::Service(
CreateEventSubscriptionError::SNSInvalidTopicFault(
parsed_error.message,
),
)
}
"SNSNoAuthorization" => {
return RusotoError::Service(
CreateEventSubscriptionError::SNSNoAuthorizationFault(
parsed_error.message,
),
)
}
"SNSTopicArnNotFound" => {
return RusotoError::Service(
CreateEventSubscriptionError::SNSTopicArnNotFoundFault(
parsed_error.message,
),
)
}
"SourceNotFound" => {
return RusotoError::Service(
CreateEventSubscriptionError::SourceNotFoundFault(parsed_error.message),
)
}
"SubscriptionAlreadyExist" => {
return RusotoError::Service(
CreateEventSubscriptionError::SubscriptionAlreadyExistFault(
parsed_error.message,
),
)
}
"SubscriptionCategoryNotFound" => {
return RusotoError::Service(
CreateEventSubscriptionError::SubscriptionCategoryNotFoundFault(
parsed_error.message,
),
)
}
"SubscriptionEventIdNotFound" => {
return RusotoError::Service(
CreateEventSubscriptionError::SubscriptionEventIdNotFoundFault(
parsed_error.message,
),
)
}
"SubscriptionSeverityNotFound" => {
return RusotoError::Service(
CreateEventSubscriptionError::SubscriptionSeverityNotFoundFault(
parsed_error.message,
),
)
}
"TagLimitExceededFault" => {
return RusotoError::Service(
CreateEventSubscriptionError::TagLimitExceededFault(
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 CreateEventSubscriptionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateEventSubscriptionError::EventSubscriptionQuotaExceededFault(ref cause) => {
write!(f, "{}", cause)
}
CreateEventSubscriptionError::InvalidTagFault(ref cause) => write!(f, "{}", cause),
CreateEventSubscriptionError::SNSInvalidTopicFault(ref cause) => write!(f, "{}", cause),
CreateEventSubscriptionError::SNSNoAuthorizationFault(ref cause) => {
write!(f, "{}", cause)
}
CreateEventSubscriptionError::SNSTopicArnNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
CreateEventSubscriptionError::SourceNotFoundFault(ref cause) => write!(f, "{}", cause),
CreateEventSubscriptionError::SubscriptionAlreadyExistFault(ref cause) => {
write!(f, "{}", cause)
}
CreateEventSubscriptionError::SubscriptionCategoryNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
CreateEventSubscriptionError::SubscriptionEventIdNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
CreateEventSubscriptionError::SubscriptionSeverityNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
CreateEventSubscriptionError::TagLimitExceededFault(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for CreateEventSubscriptionError {}
#[derive(Debug, PartialEq)]
pub enum CreateHsmClientCertificateError {
HsmClientCertificateAlreadyExistsFault(String),
HsmClientCertificateQuotaExceededFault(String),
InvalidTagFault(String),
TagLimitExceededFault(String),
}
impl CreateHsmClientCertificateError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<CreateHsmClientCertificateError> {
{
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[..] {
"HsmClientCertificateAlreadyExistsFault" => {
return RusotoError::Service(
CreateHsmClientCertificateError::HsmClientCertificateAlreadyExistsFault(
parsed_error.message,
),
)
}
"HsmClientCertificateQuotaExceededFault" => {
return RusotoError::Service(
CreateHsmClientCertificateError::HsmClientCertificateQuotaExceededFault(
parsed_error.message,
),
)
}
"InvalidTagFault" => {
return RusotoError::Service(
CreateHsmClientCertificateError::InvalidTagFault(parsed_error.message),
)
}
"TagLimitExceededFault" => {
return RusotoError::Service(
CreateHsmClientCertificateError::TagLimitExceededFault(
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 CreateHsmClientCertificateError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateHsmClientCertificateError::HsmClientCertificateAlreadyExistsFault(ref cause) => {
write!(f, "{}", cause)
}
CreateHsmClientCertificateError::HsmClientCertificateQuotaExceededFault(ref cause) => {
write!(f, "{}", cause)
}
CreateHsmClientCertificateError::InvalidTagFault(ref cause) => write!(f, "{}", cause),
CreateHsmClientCertificateError::TagLimitExceededFault(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for CreateHsmClientCertificateError {}
#[derive(Debug, PartialEq)]
pub enum CreateHsmConfigurationError {
HsmConfigurationAlreadyExistsFault(String),
HsmConfigurationQuotaExceededFault(String),
InvalidTagFault(String),
TagLimitExceededFault(String),
}
impl CreateHsmConfigurationError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateHsmConfigurationError> {
{
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[..] {
"HsmConfigurationAlreadyExistsFault" => {
return RusotoError::Service(
CreateHsmConfigurationError::HsmConfigurationAlreadyExistsFault(
parsed_error.message,
),
)
}
"HsmConfigurationQuotaExceededFault" => {
return RusotoError::Service(
CreateHsmConfigurationError::HsmConfigurationQuotaExceededFault(
parsed_error.message,
),
)
}
"InvalidTagFault" => {
return RusotoError::Service(CreateHsmConfigurationError::InvalidTagFault(
parsed_error.message,
))
}
"TagLimitExceededFault" => {
return RusotoError::Service(
CreateHsmConfigurationError::TagLimitExceededFault(
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 CreateHsmConfigurationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateHsmConfigurationError::HsmConfigurationAlreadyExistsFault(ref cause) => {
write!(f, "{}", cause)
}
CreateHsmConfigurationError::HsmConfigurationQuotaExceededFault(ref cause) => {
write!(f, "{}", cause)
}
CreateHsmConfigurationError::InvalidTagFault(ref cause) => write!(f, "{}", cause),
CreateHsmConfigurationError::TagLimitExceededFault(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateHsmConfigurationError {}
#[derive(Debug, PartialEq)]
pub enum CreateScheduledActionError {
InvalidScheduleFault(String),
InvalidScheduledActionFault(String),
ScheduledActionAlreadyExistsFault(String),
ScheduledActionQuotaExceededFault(String),
ScheduledActionTypeUnsupportedFault(String),
UnauthorizedOperation(String),
}
impl CreateScheduledActionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateScheduledActionError> {
{
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[..] {
"InvalidSchedule" => {
return RusotoError::Service(
CreateScheduledActionError::InvalidScheduleFault(parsed_error.message),
)
}
"InvalidScheduledAction" => {
return RusotoError::Service(
CreateScheduledActionError::InvalidScheduledActionFault(
parsed_error.message,
),
)
}
"ScheduledActionAlreadyExists" => {
return RusotoError::Service(
CreateScheduledActionError::ScheduledActionAlreadyExistsFault(
parsed_error.message,
),
)
}
"ScheduledActionQuotaExceeded" => {
return RusotoError::Service(
CreateScheduledActionError::ScheduledActionQuotaExceededFault(
parsed_error.message,
),
)
}
"ScheduledActionTypeUnsupported" => {
return RusotoError::Service(
CreateScheduledActionError::ScheduledActionTypeUnsupportedFault(
parsed_error.message,
),
)
}
"UnauthorizedOperation" => {
return RusotoError::Service(
CreateScheduledActionError::UnauthorizedOperation(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 CreateScheduledActionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateScheduledActionError::InvalidScheduleFault(ref cause) => write!(f, "{}", cause),
CreateScheduledActionError::InvalidScheduledActionFault(ref cause) => {
write!(f, "{}", cause)
}
CreateScheduledActionError::ScheduledActionAlreadyExistsFault(ref cause) => {
write!(f, "{}", cause)
}
CreateScheduledActionError::ScheduledActionQuotaExceededFault(ref cause) => {
write!(f, "{}", cause)
}
CreateScheduledActionError::ScheduledActionTypeUnsupportedFault(ref cause) => {
write!(f, "{}", cause)
}
CreateScheduledActionError::UnauthorizedOperation(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateScheduledActionError {}
#[derive(Debug, PartialEq)]
pub enum CreateSnapshotCopyGrantError {
DependentServiceRequestThrottlingFault(String),
InvalidTagFault(String),
LimitExceededFault(String),
SnapshotCopyGrantAlreadyExistsFault(String),
SnapshotCopyGrantQuotaExceededFault(String),
TagLimitExceededFault(String),
}
impl CreateSnapshotCopyGrantError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateSnapshotCopyGrantError> {
{
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[..] {
"DependentServiceRequestThrottlingFault" => {
return RusotoError::Service(
CreateSnapshotCopyGrantError::DependentServiceRequestThrottlingFault(
parsed_error.message,
),
)
}
"InvalidTagFault" => {
return RusotoError::Service(CreateSnapshotCopyGrantError::InvalidTagFault(
parsed_error.message,
))
}
"LimitExceededFault" => {
return RusotoError::Service(
CreateSnapshotCopyGrantError::LimitExceededFault(parsed_error.message),
)
}
"SnapshotCopyGrantAlreadyExistsFault" => {
return RusotoError::Service(
CreateSnapshotCopyGrantError::SnapshotCopyGrantAlreadyExistsFault(
parsed_error.message,
),
)
}
"SnapshotCopyGrantQuotaExceededFault" => {
return RusotoError::Service(
CreateSnapshotCopyGrantError::SnapshotCopyGrantQuotaExceededFault(
parsed_error.message,
),
)
}
"TagLimitExceededFault" => {
return RusotoError::Service(
CreateSnapshotCopyGrantError::TagLimitExceededFault(
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 CreateSnapshotCopyGrantError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateSnapshotCopyGrantError::DependentServiceRequestThrottlingFault(ref cause) => {
write!(f, "{}", cause)
}
CreateSnapshotCopyGrantError::InvalidTagFault(ref cause) => write!(f, "{}", cause),
CreateSnapshotCopyGrantError::LimitExceededFault(ref cause) => write!(f, "{}", cause),
CreateSnapshotCopyGrantError::SnapshotCopyGrantAlreadyExistsFault(ref cause) => {
write!(f, "{}", cause)
}
CreateSnapshotCopyGrantError::SnapshotCopyGrantQuotaExceededFault(ref cause) => {
write!(f, "{}", cause)
}
CreateSnapshotCopyGrantError::TagLimitExceededFault(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for CreateSnapshotCopyGrantError {}
#[derive(Debug, PartialEq)]
pub enum CreateSnapshotScheduleError {
InvalidScheduleFault(String),
ScheduleDefinitionTypeUnsupportedFault(String),
SnapshotScheduleAlreadyExistsFault(String),
SnapshotScheduleQuotaExceededFault(String),
TagLimitExceededFault(String),
}
impl CreateSnapshotScheduleError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateSnapshotScheduleError> {
{
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[..] {
"InvalidSchedule" => {
return RusotoError::Service(
CreateSnapshotScheduleError::InvalidScheduleFault(parsed_error.message),
)
}
"ScheduleDefinitionTypeUnsupported" => {
return RusotoError::Service(
CreateSnapshotScheduleError::ScheduleDefinitionTypeUnsupportedFault(
parsed_error.message,
),
)
}
"SnapshotScheduleAlreadyExists" => {
return RusotoError::Service(
CreateSnapshotScheduleError::SnapshotScheduleAlreadyExistsFault(
parsed_error.message,
),
)
}
"SnapshotScheduleQuotaExceeded" => {
return RusotoError::Service(
CreateSnapshotScheduleError::SnapshotScheduleQuotaExceededFault(
parsed_error.message,
),
)
}
"TagLimitExceededFault" => {
return RusotoError::Service(
CreateSnapshotScheduleError::TagLimitExceededFault(
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 CreateSnapshotScheduleError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateSnapshotScheduleError::InvalidScheduleFault(ref cause) => write!(f, "{}", cause),
CreateSnapshotScheduleError::ScheduleDefinitionTypeUnsupportedFault(ref cause) => {
write!(f, "{}", cause)
}
CreateSnapshotScheduleError::SnapshotScheduleAlreadyExistsFault(ref cause) => {
write!(f, "{}", cause)
}
CreateSnapshotScheduleError::SnapshotScheduleQuotaExceededFault(ref cause) => {
write!(f, "{}", cause)
}
CreateSnapshotScheduleError::TagLimitExceededFault(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateSnapshotScheduleError {}
#[derive(Debug, PartialEq)]
pub enum CreateTagsError {
InvalidTagFault(String),
ResourceNotFoundFault(String),
TagLimitExceededFault(String),
}
impl CreateTagsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateTagsError> {
{
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[..] {
"InvalidTagFault" => {
return RusotoError::Service(CreateTagsError::InvalidTagFault(
parsed_error.message,
))
}
"ResourceNotFoundFault" => {
return RusotoError::Service(CreateTagsError::ResourceNotFoundFault(
parsed_error.message,
))
}
"TagLimitExceededFault" => {
return RusotoError::Service(CreateTagsError::TagLimitExceededFault(
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 CreateTagsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateTagsError::InvalidTagFault(ref cause) => write!(f, "{}", cause),
CreateTagsError::ResourceNotFoundFault(ref cause) => write!(f, "{}", cause),
CreateTagsError::TagLimitExceededFault(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateTagsError {}
#[derive(Debug, PartialEq)]
pub enum CreateUsageLimitError {
ClusterNotFoundFault(String),
InvalidClusterStateFault(String),
InvalidUsageLimitFault(String),
LimitExceededFault(String),
TagLimitExceededFault(String),
UnsupportedOperationFault(String),
UsageLimitAlreadyExistsFault(String),
}
impl CreateUsageLimitError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateUsageLimitError> {
{
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[..] {
"ClusterNotFound" => {
return RusotoError::Service(CreateUsageLimitError::ClusterNotFoundFault(
parsed_error.message,
))
}
"InvalidClusterState" => {
return RusotoError::Service(
CreateUsageLimitError::InvalidClusterStateFault(parsed_error.message),
)
}
"InvalidUsageLimit" => {
return RusotoError::Service(CreateUsageLimitError::InvalidUsageLimitFault(
parsed_error.message,
))
}
"LimitExceededFault" => {
return RusotoError::Service(CreateUsageLimitError::LimitExceededFault(
parsed_error.message,
))
}
"TagLimitExceededFault" => {
return RusotoError::Service(CreateUsageLimitError::TagLimitExceededFault(
parsed_error.message,
))
}
"UnsupportedOperation" => {
return RusotoError::Service(
CreateUsageLimitError::UnsupportedOperationFault(parsed_error.message),
)
}
"UsageLimitAlreadyExists" => {
return RusotoError::Service(
CreateUsageLimitError::UsageLimitAlreadyExistsFault(
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 CreateUsageLimitError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateUsageLimitError::ClusterNotFoundFault(ref cause) => write!(f, "{}", cause),
CreateUsageLimitError::InvalidClusterStateFault(ref cause) => write!(f, "{}", cause),
CreateUsageLimitError::InvalidUsageLimitFault(ref cause) => write!(f, "{}", cause),
CreateUsageLimitError::LimitExceededFault(ref cause) => write!(f, "{}", cause),
CreateUsageLimitError::TagLimitExceededFault(ref cause) => write!(f, "{}", cause),
CreateUsageLimitError::UnsupportedOperationFault(ref cause) => write!(f, "{}", cause),
CreateUsageLimitError::UsageLimitAlreadyExistsFault(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for CreateUsageLimitError {}
#[derive(Debug, PartialEq)]
pub enum DeleteClusterError {
ClusterNotFoundFault(String),
ClusterSnapshotAlreadyExistsFault(String),
ClusterSnapshotQuotaExceededFault(String),
InvalidClusterStateFault(String),
InvalidRetentionPeriodFault(String),
}
impl DeleteClusterError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteClusterError> {
{
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[..] {
"ClusterNotFound" => {
return RusotoError::Service(DeleteClusterError::ClusterNotFoundFault(
parsed_error.message,
))
}
"ClusterSnapshotAlreadyExists" => {
return RusotoError::Service(
DeleteClusterError::ClusterSnapshotAlreadyExistsFault(
parsed_error.message,
),
)
}
"ClusterSnapshotQuotaExceeded" => {
return RusotoError::Service(
DeleteClusterError::ClusterSnapshotQuotaExceededFault(
parsed_error.message,
),
)
}
"InvalidClusterState" => {
return RusotoError::Service(DeleteClusterError::InvalidClusterStateFault(
parsed_error.message,
))
}
"InvalidRetentionPeriodFault" => {
return RusotoError::Service(
DeleteClusterError::InvalidRetentionPeriodFault(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 DeleteClusterError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteClusterError::ClusterNotFoundFault(ref cause) => write!(f, "{}", cause),
DeleteClusterError::ClusterSnapshotAlreadyExistsFault(ref cause) => {
write!(f, "{}", cause)
}
DeleteClusterError::ClusterSnapshotQuotaExceededFault(ref cause) => {
write!(f, "{}", cause)
}
DeleteClusterError::InvalidClusterStateFault(ref cause) => write!(f, "{}", cause),
DeleteClusterError::InvalidRetentionPeriodFault(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteClusterError {}
#[derive(Debug, PartialEq)]
pub enum DeleteClusterParameterGroupError {
ClusterParameterGroupNotFoundFault(String),
InvalidClusterParameterGroupStateFault(String),
}
impl DeleteClusterParameterGroupError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DeleteClusterParameterGroupError> {
{
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[..] {
"ClusterParameterGroupNotFound" => {
return RusotoError::Service(
DeleteClusterParameterGroupError::ClusterParameterGroupNotFoundFault(
parsed_error.message,
),
)
}
"InvalidClusterParameterGroupState" => return RusotoError::Service(
DeleteClusterParameterGroupError::InvalidClusterParameterGroupStateFault(
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 DeleteClusterParameterGroupError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteClusterParameterGroupError::ClusterParameterGroupNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
DeleteClusterParameterGroupError::InvalidClusterParameterGroupStateFault(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DeleteClusterParameterGroupError {}
#[derive(Debug, PartialEq)]
pub enum DeleteClusterSecurityGroupError {
ClusterSecurityGroupNotFoundFault(String),
InvalidClusterSecurityGroupStateFault(String),
}
impl DeleteClusterSecurityGroupError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DeleteClusterSecurityGroupError> {
{
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[..] {
"ClusterSecurityGroupNotFound" => {
return RusotoError::Service(
DeleteClusterSecurityGroupError::ClusterSecurityGroupNotFoundFault(
parsed_error.message,
),
)
}
"InvalidClusterSecurityGroupState" => {
return RusotoError::Service(
DeleteClusterSecurityGroupError::InvalidClusterSecurityGroupStateFault(
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 DeleteClusterSecurityGroupError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteClusterSecurityGroupError::ClusterSecurityGroupNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
DeleteClusterSecurityGroupError::InvalidClusterSecurityGroupStateFault(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DeleteClusterSecurityGroupError {}
#[derive(Debug, PartialEq)]
pub enum DeleteClusterSnapshotError {
ClusterSnapshotNotFoundFault(String),
InvalidClusterSnapshotStateFault(String),
}
impl DeleteClusterSnapshotError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteClusterSnapshotError> {
{
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[..] {
"ClusterSnapshotNotFound" => {
return RusotoError::Service(
DeleteClusterSnapshotError::ClusterSnapshotNotFoundFault(
parsed_error.message,
),
)
}
"InvalidClusterSnapshotState" => {
return RusotoError::Service(
DeleteClusterSnapshotError::InvalidClusterSnapshotStateFault(
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 DeleteClusterSnapshotError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteClusterSnapshotError::ClusterSnapshotNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
DeleteClusterSnapshotError::InvalidClusterSnapshotStateFault(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DeleteClusterSnapshotError {}
#[derive(Debug, PartialEq)]
pub enum DeleteClusterSubnetGroupError {
ClusterSubnetGroupNotFoundFault(String),
InvalidClusterSubnetGroupStateFault(String),
InvalidClusterSubnetStateFault(String),
}
impl DeleteClusterSubnetGroupError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteClusterSubnetGroupError> {
{
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[..] {
"ClusterSubnetGroupNotFoundFault" => {
return RusotoError::Service(
DeleteClusterSubnetGroupError::ClusterSubnetGroupNotFoundFault(
parsed_error.message,
),
)
}
"InvalidClusterSubnetGroupStateFault" => {
return RusotoError::Service(
DeleteClusterSubnetGroupError::InvalidClusterSubnetGroupStateFault(
parsed_error.message,
),
)
}
"InvalidClusterSubnetStateFault" => {
return RusotoError::Service(
DeleteClusterSubnetGroupError::InvalidClusterSubnetStateFault(
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 DeleteClusterSubnetGroupError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteClusterSubnetGroupError::ClusterSubnetGroupNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
DeleteClusterSubnetGroupError::InvalidClusterSubnetGroupStateFault(ref cause) => {
write!(f, "{}", cause)
}
DeleteClusterSubnetGroupError::InvalidClusterSubnetStateFault(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DeleteClusterSubnetGroupError {}
#[derive(Debug, PartialEq)]
pub enum DeleteEventSubscriptionError {
InvalidSubscriptionStateFault(String),
SubscriptionNotFoundFault(String),
}
impl DeleteEventSubscriptionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteEventSubscriptionError> {
{
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[..] {
"InvalidSubscriptionStateFault" => {
return RusotoError::Service(
DeleteEventSubscriptionError::InvalidSubscriptionStateFault(
parsed_error.message,
),
)
}
"SubscriptionNotFound" => {
return RusotoError::Service(
DeleteEventSubscriptionError::SubscriptionNotFoundFault(
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 DeleteEventSubscriptionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteEventSubscriptionError::InvalidSubscriptionStateFault(ref cause) => {
write!(f, "{}", cause)
}
DeleteEventSubscriptionError::SubscriptionNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DeleteEventSubscriptionError {}
#[derive(Debug, PartialEq)]
pub enum DeleteHsmClientCertificateError {
HsmClientCertificateNotFoundFault(String),
InvalidHsmClientCertificateStateFault(String),
}
impl DeleteHsmClientCertificateError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DeleteHsmClientCertificateError> {
{
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[..] {
"HsmClientCertificateNotFoundFault" => {
return RusotoError::Service(
DeleteHsmClientCertificateError::HsmClientCertificateNotFoundFault(
parsed_error.message,
),
)
}
"InvalidHsmClientCertificateStateFault" => {
return RusotoError::Service(
DeleteHsmClientCertificateError::InvalidHsmClientCertificateStateFault(
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 DeleteHsmClientCertificateError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteHsmClientCertificateError::HsmClientCertificateNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
DeleteHsmClientCertificateError::InvalidHsmClientCertificateStateFault(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DeleteHsmClientCertificateError {}
#[derive(Debug, PartialEq)]
pub enum DeleteHsmConfigurationError {
HsmConfigurationNotFoundFault(String),
InvalidHsmConfigurationStateFault(String),
}
impl DeleteHsmConfigurationError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteHsmConfigurationError> {
{
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[..] {
"HsmConfigurationNotFoundFault" => {
return RusotoError::Service(
DeleteHsmConfigurationError::HsmConfigurationNotFoundFault(
parsed_error.message,
),
)
}
"InvalidHsmConfigurationStateFault" => {
return RusotoError::Service(
DeleteHsmConfigurationError::InvalidHsmConfigurationStateFault(
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 DeleteHsmConfigurationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteHsmConfigurationError::HsmConfigurationNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
DeleteHsmConfigurationError::InvalidHsmConfigurationStateFault(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DeleteHsmConfigurationError {}
#[derive(Debug, PartialEq)]
pub enum DeleteScheduledActionError {
ScheduledActionNotFoundFault(String),
UnauthorizedOperation(String),
}
impl DeleteScheduledActionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteScheduledActionError> {
{
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[..] {
"ScheduledActionNotFound" => {
return RusotoError::Service(
DeleteScheduledActionError::ScheduledActionNotFoundFault(
parsed_error.message,
),
)
}
"UnauthorizedOperation" => {
return RusotoError::Service(
DeleteScheduledActionError::UnauthorizedOperation(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 DeleteScheduledActionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteScheduledActionError::ScheduledActionNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
DeleteScheduledActionError::UnauthorizedOperation(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteScheduledActionError {}
#[derive(Debug, PartialEq)]
pub enum DeleteSnapshotCopyGrantError {
InvalidSnapshotCopyGrantStateFault(String),
SnapshotCopyGrantNotFoundFault(String),
}
impl DeleteSnapshotCopyGrantError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteSnapshotCopyGrantError> {
{
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[..] {
"InvalidSnapshotCopyGrantStateFault" => {
return RusotoError::Service(
DeleteSnapshotCopyGrantError::InvalidSnapshotCopyGrantStateFault(
parsed_error.message,
),
)
}
"SnapshotCopyGrantNotFoundFault" => {
return RusotoError::Service(
DeleteSnapshotCopyGrantError::SnapshotCopyGrantNotFoundFault(
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 DeleteSnapshotCopyGrantError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteSnapshotCopyGrantError::InvalidSnapshotCopyGrantStateFault(ref cause) => {
write!(f, "{}", cause)
}
DeleteSnapshotCopyGrantError::SnapshotCopyGrantNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DeleteSnapshotCopyGrantError {}
#[derive(Debug, PartialEq)]
pub enum DeleteSnapshotScheduleError {
InvalidClusterSnapshotScheduleStateFault(String),
SnapshotScheduleNotFoundFault(String),
}
impl DeleteSnapshotScheduleError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteSnapshotScheduleError> {
{
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[..] {
"InvalidClusterSnapshotScheduleState" => {
return RusotoError::Service(
DeleteSnapshotScheduleError::InvalidClusterSnapshotScheduleStateFault(
parsed_error.message,
),
)
}
"SnapshotScheduleNotFound" => {
return RusotoError::Service(
DeleteSnapshotScheduleError::SnapshotScheduleNotFoundFault(
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 DeleteSnapshotScheduleError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteSnapshotScheduleError::InvalidClusterSnapshotScheduleStateFault(ref cause) => {
write!(f, "{}", cause)
}
DeleteSnapshotScheduleError::SnapshotScheduleNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DeleteSnapshotScheduleError {}
#[derive(Debug, PartialEq)]
pub enum DeleteTagsError {
InvalidTagFault(String),
ResourceNotFoundFault(String),
}
impl DeleteTagsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteTagsError> {
{
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[..] {
"InvalidTagFault" => {
return RusotoError::Service(DeleteTagsError::InvalidTagFault(
parsed_error.message,
))
}
"ResourceNotFoundFault" => {
return RusotoError::Service(DeleteTagsError::ResourceNotFoundFault(
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 DeleteTagsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteTagsError::InvalidTagFault(ref cause) => write!(f, "{}", cause),
DeleteTagsError::ResourceNotFoundFault(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteTagsError {}
#[derive(Debug, PartialEq)]
pub enum DeleteUsageLimitError {
UnsupportedOperationFault(String),
UsageLimitNotFoundFault(String),
}
impl DeleteUsageLimitError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteUsageLimitError> {
{
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[..] {
"UnsupportedOperation" => {
return RusotoError::Service(
DeleteUsageLimitError::UnsupportedOperationFault(parsed_error.message),
)
}
"UsageLimitNotFound" => {
return RusotoError::Service(
DeleteUsageLimitError::UsageLimitNotFoundFault(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 DeleteUsageLimitError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteUsageLimitError::UnsupportedOperationFault(ref cause) => write!(f, "{}", cause),
DeleteUsageLimitError::UsageLimitNotFoundFault(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteUsageLimitError {}
#[derive(Debug, PartialEq)]
pub enum DescribeAccountAttributesError {}
impl DescribeAccountAttributesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeAccountAttributesError> {
{
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 DescribeAccountAttributesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {}
}
}
impl Error for DescribeAccountAttributesError {}
#[derive(Debug, PartialEq)]
pub enum DescribeClusterDbRevisionsError {
ClusterNotFoundFault(String),
InvalidClusterStateFault(String),
}
impl DescribeClusterDbRevisionsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeClusterDbRevisionsError> {
{
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[..] {
"ClusterNotFound" => {
return RusotoError::Service(
DescribeClusterDbRevisionsError::ClusterNotFoundFault(
parsed_error.message,
),
)
}
"InvalidClusterState" => {
return RusotoError::Service(
DescribeClusterDbRevisionsError::InvalidClusterStateFault(
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 DescribeClusterDbRevisionsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeClusterDbRevisionsError::ClusterNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
DescribeClusterDbRevisionsError::InvalidClusterStateFault(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DescribeClusterDbRevisionsError {}
#[derive(Debug, PartialEq)]
pub enum DescribeClusterParameterGroupsError {
ClusterParameterGroupNotFoundFault(String),
InvalidTagFault(String),
}
impl DescribeClusterParameterGroupsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeClusterParameterGroupsError> {
{
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[..] {
"ClusterParameterGroupNotFound" => {
return RusotoError::Service(
DescribeClusterParameterGroupsError::ClusterParameterGroupNotFoundFault(
parsed_error.message,
),
)
}
"InvalidTagFault" => {
return RusotoError::Service(
DescribeClusterParameterGroupsError::InvalidTagFault(
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 DescribeClusterParameterGroupsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeClusterParameterGroupsError::ClusterParameterGroupNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
DescribeClusterParameterGroupsError::InvalidTagFault(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DescribeClusterParameterGroupsError {}
#[derive(Debug, PartialEq)]
pub enum DescribeClusterParametersError {
ClusterParameterGroupNotFoundFault(String),
}
impl DescribeClusterParametersError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeClusterParametersError> {
{
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[..] {
"ClusterParameterGroupNotFound" => {
return RusotoError::Service(
DescribeClusterParametersError::ClusterParameterGroupNotFoundFault(
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 DescribeClusterParametersError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeClusterParametersError::ClusterParameterGroupNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DescribeClusterParametersError {}
#[derive(Debug, PartialEq)]
pub enum DescribeClusterSecurityGroupsError {
ClusterSecurityGroupNotFoundFault(String),
InvalidTagFault(String),
}
impl DescribeClusterSecurityGroupsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeClusterSecurityGroupsError> {
{
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[..] {
"ClusterSecurityGroupNotFound" => {
return RusotoError::Service(
DescribeClusterSecurityGroupsError::ClusterSecurityGroupNotFoundFault(
parsed_error.message,
),
)
}
"InvalidTagFault" => {
return RusotoError::Service(
DescribeClusterSecurityGroupsError::InvalidTagFault(
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 DescribeClusterSecurityGroupsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeClusterSecurityGroupsError::ClusterSecurityGroupNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
DescribeClusterSecurityGroupsError::InvalidTagFault(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DescribeClusterSecurityGroupsError {}
#[derive(Debug, PartialEq)]
pub enum DescribeClusterSnapshotsError {
ClusterNotFoundFault(String),
ClusterSnapshotNotFoundFault(String),
InvalidTagFault(String),
}
impl DescribeClusterSnapshotsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeClusterSnapshotsError> {
{
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[..] {
"ClusterNotFound" => {
return RusotoError::Service(
DescribeClusterSnapshotsError::ClusterNotFoundFault(
parsed_error.message,
),
)
}
"ClusterSnapshotNotFound" => {
return RusotoError::Service(
DescribeClusterSnapshotsError::ClusterSnapshotNotFoundFault(
parsed_error.message,
),
)
}
"InvalidTagFault" => {
return RusotoError::Service(
DescribeClusterSnapshotsError::InvalidTagFault(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 DescribeClusterSnapshotsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeClusterSnapshotsError::ClusterNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
DescribeClusterSnapshotsError::ClusterSnapshotNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
DescribeClusterSnapshotsError::InvalidTagFault(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeClusterSnapshotsError {}
#[derive(Debug, PartialEq)]
pub enum DescribeClusterSubnetGroupsError {
ClusterSubnetGroupNotFoundFault(String),
InvalidTagFault(String),
}
impl DescribeClusterSubnetGroupsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeClusterSubnetGroupsError> {
{
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[..] {
"ClusterSubnetGroupNotFoundFault" => {
return RusotoError::Service(
DescribeClusterSubnetGroupsError::ClusterSubnetGroupNotFoundFault(
parsed_error.message,
),
)
}
"InvalidTagFault" => {
return RusotoError::Service(
DescribeClusterSubnetGroupsError::InvalidTagFault(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 DescribeClusterSubnetGroupsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeClusterSubnetGroupsError::ClusterSubnetGroupNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
DescribeClusterSubnetGroupsError::InvalidTagFault(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeClusterSubnetGroupsError {}
#[derive(Debug, PartialEq)]
pub enum DescribeClusterTracksError {
InvalidClusterTrackFault(String),
UnauthorizedOperation(String),
}
impl DescribeClusterTracksError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeClusterTracksError> {
{
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[..] {
"InvalidClusterTrack" => {
return RusotoError::Service(
DescribeClusterTracksError::InvalidClusterTrackFault(
parsed_error.message,
),
)
}
"UnauthorizedOperation" => {
return RusotoError::Service(
DescribeClusterTracksError::UnauthorizedOperation(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 DescribeClusterTracksError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeClusterTracksError::InvalidClusterTrackFault(ref cause) => {
write!(f, "{}", cause)
}
DescribeClusterTracksError::UnauthorizedOperation(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeClusterTracksError {}
#[derive(Debug, PartialEq)]
pub enum DescribeClusterVersionsError {}
impl DescribeClusterVersionsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeClusterVersionsError> {
{
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 DescribeClusterVersionsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {}
}
}
impl Error for DescribeClusterVersionsError {}
#[derive(Debug, PartialEq)]
pub enum DescribeClustersError {
ClusterNotFoundFault(String),
InvalidTagFault(String),
}
impl DescribeClustersError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeClustersError> {
{
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[..] {
"ClusterNotFound" => {
return RusotoError::Service(DescribeClustersError::ClusterNotFoundFault(
parsed_error.message,
))
}
"InvalidTagFault" => {
return RusotoError::Service(DescribeClustersError::InvalidTagFault(
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 DescribeClustersError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeClustersError::ClusterNotFoundFault(ref cause) => write!(f, "{}", cause),
DescribeClustersError::InvalidTagFault(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeClustersError {}
#[derive(Debug, PartialEq)]
pub enum DescribeDefaultClusterParametersError {}
impl DescribeDefaultClusterParametersError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeDefaultClusterParametersError> {
{
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 DescribeDefaultClusterParametersError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {}
}
}
impl Error for DescribeDefaultClusterParametersError {}
#[derive(Debug, PartialEq)]
pub enum DescribeEventCategoriesError {}
impl DescribeEventCategoriesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeEventCategoriesError> {
{
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 DescribeEventCategoriesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {}
}
}
impl Error for DescribeEventCategoriesError {}
#[derive(Debug, PartialEq)]
pub enum DescribeEventSubscriptionsError {
InvalidTagFault(String),
SubscriptionNotFoundFault(String),
}
impl DescribeEventSubscriptionsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeEventSubscriptionsError> {
{
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[..] {
"InvalidTagFault" => {
return RusotoError::Service(
DescribeEventSubscriptionsError::InvalidTagFault(parsed_error.message),
)
}
"SubscriptionNotFound" => {
return RusotoError::Service(
DescribeEventSubscriptionsError::SubscriptionNotFoundFault(
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 DescribeEventSubscriptionsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeEventSubscriptionsError::InvalidTagFault(ref cause) => write!(f, "{}", cause),
DescribeEventSubscriptionsError::SubscriptionNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DescribeEventSubscriptionsError {}
#[derive(Debug, PartialEq)]
pub enum DescribeEventsError {}
impl DescribeEventsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeEventsError> {
{
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 DescribeEventsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {}
}
}
impl Error for DescribeEventsError {}
#[derive(Debug, PartialEq)]
pub enum DescribeHsmClientCertificatesError {
HsmClientCertificateNotFoundFault(String),
InvalidTagFault(String),
}
impl DescribeHsmClientCertificatesError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeHsmClientCertificatesError> {
{
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[..] {
"HsmClientCertificateNotFoundFault" => {
return RusotoError::Service(
DescribeHsmClientCertificatesError::HsmClientCertificateNotFoundFault(
parsed_error.message,
),
)
}
"InvalidTagFault" => {
return RusotoError::Service(
DescribeHsmClientCertificatesError::InvalidTagFault(
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 DescribeHsmClientCertificatesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeHsmClientCertificatesError::HsmClientCertificateNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
DescribeHsmClientCertificatesError::InvalidTagFault(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DescribeHsmClientCertificatesError {}
#[derive(Debug, PartialEq)]
pub enum DescribeHsmConfigurationsError {
HsmConfigurationNotFoundFault(String),
InvalidTagFault(String),
}
impl DescribeHsmConfigurationsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeHsmConfigurationsError> {
{
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[..] {
"HsmConfigurationNotFoundFault" => {
return RusotoError::Service(
DescribeHsmConfigurationsError::HsmConfigurationNotFoundFault(
parsed_error.message,
),
)
}
"InvalidTagFault" => {
return RusotoError::Service(
DescribeHsmConfigurationsError::InvalidTagFault(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 DescribeHsmConfigurationsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeHsmConfigurationsError::HsmConfigurationNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
DescribeHsmConfigurationsError::InvalidTagFault(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeHsmConfigurationsError {}
#[derive(Debug, PartialEq)]
pub enum DescribeLoggingStatusError {
ClusterNotFoundFault(String),
}
impl DescribeLoggingStatusError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeLoggingStatusError> {
{
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[..] {
"ClusterNotFound" => {
return RusotoError::Service(
DescribeLoggingStatusError::ClusterNotFoundFault(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 DescribeLoggingStatusError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeLoggingStatusError::ClusterNotFoundFault(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeLoggingStatusError {}
#[derive(Debug, PartialEq)]
pub enum DescribeNodeConfigurationOptionsError {
AccessToSnapshotDeniedFault(String),
ClusterNotFoundFault(String),
ClusterSnapshotNotFoundFault(String),
InvalidClusterSnapshotStateFault(String),
}
impl DescribeNodeConfigurationOptionsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeNodeConfigurationOptionsError> {
{
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[..] {
"AccessToSnapshotDenied" => {
return RusotoError::Service(
DescribeNodeConfigurationOptionsError::AccessToSnapshotDeniedFault(
parsed_error.message,
),
)
}
"ClusterNotFound" => {
return RusotoError::Service(
DescribeNodeConfigurationOptionsError::ClusterNotFoundFault(
parsed_error.message,
),
)
}
"ClusterSnapshotNotFound" => {
return RusotoError::Service(
DescribeNodeConfigurationOptionsError::ClusterSnapshotNotFoundFault(
parsed_error.message,
),
)
}
"InvalidClusterSnapshotState" => {
return RusotoError::Service(
DescribeNodeConfigurationOptionsError::InvalidClusterSnapshotStateFault(
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 DescribeNodeConfigurationOptionsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeNodeConfigurationOptionsError::AccessToSnapshotDeniedFault(ref cause) => {
write!(f, "{}", cause)
}
DescribeNodeConfigurationOptionsError::ClusterNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
DescribeNodeConfigurationOptionsError::ClusterSnapshotNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
DescribeNodeConfigurationOptionsError::InvalidClusterSnapshotStateFault(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DescribeNodeConfigurationOptionsError {}
#[derive(Debug, PartialEq)]
pub enum DescribeOrderableClusterOptionsError {}
impl DescribeOrderableClusterOptionsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeOrderableClusterOptionsError> {
{
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 DescribeOrderableClusterOptionsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {}
}
}
impl Error for DescribeOrderableClusterOptionsError {}
#[derive(Debug, PartialEq)]
pub enum DescribeReservedNodeOfferingsError {
DependentServiceUnavailableFault(String),
ReservedNodeOfferingNotFoundFault(String),
UnsupportedOperationFault(String),
}
impl DescribeReservedNodeOfferingsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeReservedNodeOfferingsError> {
{
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[..] {
"DependentServiceUnavailableFault" => {
return RusotoError::Service(
DescribeReservedNodeOfferingsError::DependentServiceUnavailableFault(
parsed_error.message,
),
)
}
"ReservedNodeOfferingNotFound" => {
return RusotoError::Service(
DescribeReservedNodeOfferingsError::ReservedNodeOfferingNotFoundFault(
parsed_error.message,
),
)
}
"UnsupportedOperation" => {
return RusotoError::Service(
DescribeReservedNodeOfferingsError::UnsupportedOperationFault(
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 DescribeReservedNodeOfferingsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeReservedNodeOfferingsError::DependentServiceUnavailableFault(ref cause) => {
write!(f, "{}", cause)
}
DescribeReservedNodeOfferingsError::ReservedNodeOfferingNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
DescribeReservedNodeOfferingsError::UnsupportedOperationFault(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DescribeReservedNodeOfferingsError {}
#[derive(Debug, PartialEq)]
pub enum DescribeReservedNodesError {
DependentServiceUnavailableFault(String),
ReservedNodeNotFoundFault(String),
}
impl DescribeReservedNodesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeReservedNodesError> {
{
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[..] {
"DependentServiceUnavailableFault" => {
return RusotoError::Service(
DescribeReservedNodesError::DependentServiceUnavailableFault(
parsed_error.message,
),
)
}
"ReservedNodeNotFound" => {
return RusotoError::Service(
DescribeReservedNodesError::ReservedNodeNotFoundFault(
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 DescribeReservedNodesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeReservedNodesError::DependentServiceUnavailableFault(ref cause) => {
write!(f, "{}", cause)
}
DescribeReservedNodesError::ReservedNodeNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DescribeReservedNodesError {}
#[derive(Debug, PartialEq)]
pub enum DescribeResizeError {
ClusterNotFoundFault(String),
ResizeNotFoundFault(String),
}
impl DescribeResizeError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeResizeError> {
{
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[..] {
"ClusterNotFound" => {
return RusotoError::Service(DescribeResizeError::ClusterNotFoundFault(
parsed_error.message,
))
}
"ResizeNotFound" => {
return RusotoError::Service(DescribeResizeError::ResizeNotFoundFault(
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 DescribeResizeError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeResizeError::ClusterNotFoundFault(ref cause) => write!(f, "{}", cause),
DescribeResizeError::ResizeNotFoundFault(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeResizeError {}
#[derive(Debug, PartialEq)]
pub enum DescribeScheduledActionsError {
ScheduledActionNotFoundFault(String),
UnauthorizedOperation(String),
}
impl DescribeScheduledActionsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeScheduledActionsError> {
{
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[..] {
"ScheduledActionNotFound" => {
return RusotoError::Service(
DescribeScheduledActionsError::ScheduledActionNotFoundFault(
parsed_error.message,
),
)
}
"UnauthorizedOperation" => {
return RusotoError::Service(
DescribeScheduledActionsError::UnauthorizedOperation(
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 DescribeScheduledActionsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeScheduledActionsError::ScheduledActionNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
DescribeScheduledActionsError::UnauthorizedOperation(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DescribeScheduledActionsError {}
#[derive(Debug, PartialEq)]
pub enum DescribeSnapshotCopyGrantsError {
InvalidTagFault(String),
SnapshotCopyGrantNotFoundFault(String),
}
impl DescribeSnapshotCopyGrantsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeSnapshotCopyGrantsError> {
{
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[..] {
"InvalidTagFault" => {
return RusotoError::Service(
DescribeSnapshotCopyGrantsError::InvalidTagFault(parsed_error.message),
)
}
"SnapshotCopyGrantNotFoundFault" => {
return RusotoError::Service(
DescribeSnapshotCopyGrantsError::SnapshotCopyGrantNotFoundFault(
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 DescribeSnapshotCopyGrantsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeSnapshotCopyGrantsError::InvalidTagFault(ref cause) => write!(f, "{}", cause),
DescribeSnapshotCopyGrantsError::SnapshotCopyGrantNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DescribeSnapshotCopyGrantsError {}
#[derive(Debug, PartialEq)]
pub enum DescribeSnapshotSchedulesError {}
impl DescribeSnapshotSchedulesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeSnapshotSchedulesError> {
{
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 DescribeSnapshotSchedulesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {}
}
}
impl Error for DescribeSnapshotSchedulesError {}
#[derive(Debug, PartialEq)]
pub enum DescribeStorageError {}
impl DescribeStorageError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeStorageError> {
{
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 DescribeStorageError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {}
}
}
impl Error for DescribeStorageError {}
#[derive(Debug, PartialEq)]
pub enum DescribeTableRestoreStatusError {
ClusterNotFoundFault(String),
TableRestoreNotFoundFault(String),
}
impl DescribeTableRestoreStatusError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeTableRestoreStatusError> {
{
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[..] {
"ClusterNotFound" => {
return RusotoError::Service(
DescribeTableRestoreStatusError::ClusterNotFoundFault(
parsed_error.message,
),
)
}
"TableRestoreNotFoundFault" => {
return RusotoError::Service(
DescribeTableRestoreStatusError::TableRestoreNotFoundFault(
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 DescribeTableRestoreStatusError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeTableRestoreStatusError::ClusterNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
DescribeTableRestoreStatusError::TableRestoreNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DescribeTableRestoreStatusError {}
#[derive(Debug, PartialEq)]
pub enum DescribeTagsError {
InvalidTagFault(String),
ResourceNotFoundFault(String),
}
impl DescribeTagsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeTagsError> {
{
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[..] {
"InvalidTagFault" => {
return RusotoError::Service(DescribeTagsError::InvalidTagFault(
parsed_error.message,
))
}
"ResourceNotFoundFault" => {
return RusotoError::Service(DescribeTagsError::ResourceNotFoundFault(
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 DescribeTagsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeTagsError::InvalidTagFault(ref cause) => write!(f, "{}", cause),
DescribeTagsError::ResourceNotFoundFault(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeTagsError {}
#[derive(Debug, PartialEq)]
pub enum DescribeUsageLimitsError {
ClusterNotFoundFault(String),
UnsupportedOperationFault(String),
}
impl DescribeUsageLimitsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeUsageLimitsError> {
{
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[..] {
"ClusterNotFound" => {
return RusotoError::Service(
DescribeUsageLimitsError::ClusterNotFoundFault(parsed_error.message),
)
}
"UnsupportedOperation" => {
return RusotoError::Service(
DescribeUsageLimitsError::UnsupportedOperationFault(
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 DescribeUsageLimitsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeUsageLimitsError::ClusterNotFoundFault(ref cause) => write!(f, "{}", cause),
DescribeUsageLimitsError::UnsupportedOperationFault(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DescribeUsageLimitsError {}
#[derive(Debug, PartialEq)]
pub enum DisableLoggingError {
ClusterNotFoundFault(String),
}
impl DisableLoggingError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DisableLoggingError> {
{
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[..] {
"ClusterNotFound" => {
return RusotoError::Service(DisableLoggingError::ClusterNotFoundFault(
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 DisableLoggingError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DisableLoggingError::ClusterNotFoundFault(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DisableLoggingError {}
#[derive(Debug, PartialEq)]
pub enum DisableSnapshotCopyError {
ClusterNotFoundFault(String),
InvalidClusterStateFault(String),
SnapshotCopyAlreadyDisabledFault(String),
UnauthorizedOperation(String),
}
impl DisableSnapshotCopyError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DisableSnapshotCopyError> {
{
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[..] {
"ClusterNotFound" => {
return RusotoError::Service(
DisableSnapshotCopyError::ClusterNotFoundFault(parsed_error.message),
)
}
"InvalidClusterState" => {
return RusotoError::Service(
DisableSnapshotCopyError::InvalidClusterStateFault(
parsed_error.message,
),
)
}
"SnapshotCopyAlreadyDisabledFault" => {
return RusotoError::Service(
DisableSnapshotCopyError::SnapshotCopyAlreadyDisabledFault(
parsed_error.message,
),
)
}
"UnauthorizedOperation" => {
return RusotoError::Service(
DisableSnapshotCopyError::UnauthorizedOperation(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 DisableSnapshotCopyError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DisableSnapshotCopyError::ClusterNotFoundFault(ref cause) => write!(f, "{}", cause),
DisableSnapshotCopyError::InvalidClusterStateFault(ref cause) => write!(f, "{}", cause),
DisableSnapshotCopyError::SnapshotCopyAlreadyDisabledFault(ref cause) => {
write!(f, "{}", cause)
}
DisableSnapshotCopyError::UnauthorizedOperation(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DisableSnapshotCopyError {}
#[derive(Debug, PartialEq)]
pub enum EnableLoggingError {
BucketNotFoundFault(String),
ClusterNotFoundFault(String),
InsufficientS3BucketPolicyFault(String),
InvalidClusterStateFault(String),
InvalidS3BucketNameFault(String),
InvalidS3KeyPrefixFault(String),
}
impl EnableLoggingError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<EnableLoggingError> {
{
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[..] {
"BucketNotFoundFault" => {
return RusotoError::Service(EnableLoggingError::BucketNotFoundFault(
parsed_error.message,
))
}
"ClusterNotFound" => {
return RusotoError::Service(EnableLoggingError::ClusterNotFoundFault(
parsed_error.message,
))
}
"InsufficientS3BucketPolicyFault" => {
return RusotoError::Service(
EnableLoggingError::InsufficientS3BucketPolicyFault(
parsed_error.message,
),
)
}
"InvalidClusterState" => {
return RusotoError::Service(EnableLoggingError::InvalidClusterStateFault(
parsed_error.message,
))
}
"InvalidS3BucketNameFault" => {
return RusotoError::Service(EnableLoggingError::InvalidS3BucketNameFault(
parsed_error.message,
))
}
"InvalidS3KeyPrefixFault" => {
return RusotoError::Service(EnableLoggingError::InvalidS3KeyPrefixFault(
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 EnableLoggingError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
EnableLoggingError::BucketNotFoundFault(ref cause) => write!(f, "{}", cause),
EnableLoggingError::ClusterNotFoundFault(ref cause) => write!(f, "{}", cause),
EnableLoggingError::InsufficientS3BucketPolicyFault(ref cause) => {
write!(f, "{}", cause)
}
EnableLoggingError::InvalidClusterStateFault(ref cause) => write!(f, "{}", cause),
EnableLoggingError::InvalidS3BucketNameFault(ref cause) => write!(f, "{}", cause),
EnableLoggingError::InvalidS3KeyPrefixFault(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for EnableLoggingError {}
#[derive(Debug, PartialEq)]
pub enum EnableSnapshotCopyError {
ClusterNotFoundFault(String),
CopyToRegionDisabledFault(String),
DependentServiceRequestThrottlingFault(String),
IncompatibleOrderableOptions(String),
InvalidClusterStateFault(String),
InvalidRetentionPeriodFault(String),
LimitExceededFault(String),
SnapshotCopyAlreadyEnabledFault(String),
SnapshotCopyGrantNotFoundFault(String),
UnauthorizedOperation(String),
UnknownSnapshotCopyRegionFault(String),
}
impl EnableSnapshotCopyError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<EnableSnapshotCopyError> {
{
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[..] {
"ClusterNotFound" => {
return RusotoError::Service(EnableSnapshotCopyError::ClusterNotFoundFault(
parsed_error.message,
))
}
"CopyToRegionDisabledFault" => {
return RusotoError::Service(
EnableSnapshotCopyError::CopyToRegionDisabledFault(
parsed_error.message,
),
)
}
"DependentServiceRequestThrottlingFault" => {
return RusotoError::Service(
EnableSnapshotCopyError::DependentServiceRequestThrottlingFault(
parsed_error.message,
),
)
}
"IncompatibleOrderableOptions" => {
return RusotoError::Service(
EnableSnapshotCopyError::IncompatibleOrderableOptions(
parsed_error.message,
),
)
}
"InvalidClusterState" => {
return RusotoError::Service(
EnableSnapshotCopyError::InvalidClusterStateFault(parsed_error.message),
)
}
"InvalidRetentionPeriodFault" => {
return RusotoError::Service(
EnableSnapshotCopyError::InvalidRetentionPeriodFault(
parsed_error.message,
),
)
}
"LimitExceededFault" => {
return RusotoError::Service(EnableSnapshotCopyError::LimitExceededFault(
parsed_error.message,
))
}
"SnapshotCopyAlreadyEnabledFault" => {
return RusotoError::Service(
EnableSnapshotCopyError::SnapshotCopyAlreadyEnabledFault(
parsed_error.message,
),
)
}
"SnapshotCopyGrantNotFoundFault" => {
return RusotoError::Service(
EnableSnapshotCopyError::SnapshotCopyGrantNotFoundFault(
parsed_error.message,
),
)
}
"UnauthorizedOperation" => {
return RusotoError::Service(
EnableSnapshotCopyError::UnauthorizedOperation(parsed_error.message),
)
}
"UnknownSnapshotCopyRegionFault" => {
return RusotoError::Service(
EnableSnapshotCopyError::UnknownSnapshotCopyRegionFault(
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 EnableSnapshotCopyError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
EnableSnapshotCopyError::ClusterNotFoundFault(ref cause) => write!(f, "{}", cause),
EnableSnapshotCopyError::CopyToRegionDisabledFault(ref cause) => write!(f, "{}", cause),
EnableSnapshotCopyError::DependentServiceRequestThrottlingFault(ref cause) => {
write!(f, "{}", cause)
}
EnableSnapshotCopyError::IncompatibleOrderableOptions(ref cause) => {
write!(f, "{}", cause)
}
EnableSnapshotCopyError::InvalidClusterStateFault(ref cause) => write!(f, "{}", cause),
EnableSnapshotCopyError::InvalidRetentionPeriodFault(ref cause) => {
write!(f, "{}", cause)
}
EnableSnapshotCopyError::LimitExceededFault(ref cause) => write!(f, "{}", cause),
EnableSnapshotCopyError::SnapshotCopyAlreadyEnabledFault(ref cause) => {
write!(f, "{}", cause)
}
EnableSnapshotCopyError::SnapshotCopyGrantNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
EnableSnapshotCopyError::UnauthorizedOperation(ref cause) => write!(f, "{}", cause),
EnableSnapshotCopyError::UnknownSnapshotCopyRegionFault(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for EnableSnapshotCopyError {}
#[derive(Debug, PartialEq)]
pub enum GetClusterCredentialsError {
ClusterNotFoundFault(String),
UnsupportedOperationFault(String),
}
impl GetClusterCredentialsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetClusterCredentialsError> {
{
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[..] {
"ClusterNotFound" => {
return RusotoError::Service(
GetClusterCredentialsError::ClusterNotFoundFault(parsed_error.message),
)
}
"UnsupportedOperation" => {
return RusotoError::Service(
GetClusterCredentialsError::UnsupportedOperationFault(
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 GetClusterCredentialsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetClusterCredentialsError::ClusterNotFoundFault(ref cause) => write!(f, "{}", cause),
GetClusterCredentialsError::UnsupportedOperationFault(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for GetClusterCredentialsError {}
#[derive(Debug, PartialEq)]
pub enum GetReservedNodeExchangeOfferingsError {
DependentServiceUnavailableFault(String),
InvalidReservedNodeStateFault(String),
ReservedNodeAlreadyMigratedFault(String),
ReservedNodeNotFoundFault(String),
ReservedNodeOfferingNotFoundFault(String),
UnsupportedOperationFault(String),
}
impl GetReservedNodeExchangeOfferingsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<GetReservedNodeExchangeOfferingsError> {
{
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[..] {
"DependentServiceUnavailableFault" => {
return RusotoError::Service(
GetReservedNodeExchangeOfferingsError::DependentServiceUnavailableFault(
parsed_error.message,
),
)
}
"InvalidReservedNodeState" => {
return RusotoError::Service(
GetReservedNodeExchangeOfferingsError::InvalidReservedNodeStateFault(
parsed_error.message,
),
)
}
"ReservedNodeAlreadyMigrated" => {
return RusotoError::Service(
GetReservedNodeExchangeOfferingsError::ReservedNodeAlreadyMigratedFault(
parsed_error.message,
),
)
}
"ReservedNodeNotFound" => {
return RusotoError::Service(
GetReservedNodeExchangeOfferingsError::ReservedNodeNotFoundFault(
parsed_error.message,
),
)
}
"ReservedNodeOfferingNotFound" => return RusotoError::Service(
GetReservedNodeExchangeOfferingsError::ReservedNodeOfferingNotFoundFault(
parsed_error.message,
),
),
"UnsupportedOperation" => {
return RusotoError::Service(
GetReservedNodeExchangeOfferingsError::UnsupportedOperationFault(
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 GetReservedNodeExchangeOfferingsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetReservedNodeExchangeOfferingsError::DependentServiceUnavailableFault(ref cause) => {
write!(f, "{}", cause)
}
GetReservedNodeExchangeOfferingsError::InvalidReservedNodeStateFault(ref cause) => {
write!(f, "{}", cause)
}
GetReservedNodeExchangeOfferingsError::ReservedNodeAlreadyMigratedFault(ref cause) => {
write!(f, "{}", cause)
}
GetReservedNodeExchangeOfferingsError::ReservedNodeNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
GetReservedNodeExchangeOfferingsError::ReservedNodeOfferingNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
GetReservedNodeExchangeOfferingsError::UnsupportedOperationFault(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for GetReservedNodeExchangeOfferingsError {}
#[derive(Debug, PartialEq)]
pub enum ModifyClusterError {
ClusterAlreadyExistsFault(String),
ClusterNotFoundFault(String),
ClusterParameterGroupNotFoundFault(String),
ClusterSecurityGroupNotFoundFault(String),
DependentServiceRequestThrottlingFault(String),
HsmClientCertificateNotFoundFault(String),
HsmConfigurationNotFoundFault(String),
InsufficientClusterCapacityFault(String),
InvalidClusterSecurityGroupStateFault(String),
InvalidClusterStateFault(String),
InvalidClusterTrackFault(String),
InvalidElasticIpFault(String),
InvalidRetentionPeriodFault(String),
LimitExceededFault(String),
NumberOfNodesPerClusterLimitExceededFault(String),
NumberOfNodesQuotaExceededFault(String),
TableLimitExceededFault(String),
UnauthorizedOperation(String),
UnsupportedOptionFault(String),
}
impl ModifyClusterError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ModifyClusterError> {
{
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[..] {
"ClusterAlreadyExists" => {
return RusotoError::Service(ModifyClusterError::ClusterAlreadyExistsFault(
parsed_error.message,
))
}
"ClusterNotFound" => {
return RusotoError::Service(ModifyClusterError::ClusterNotFoundFault(
parsed_error.message,
))
}
"ClusterParameterGroupNotFound" => {
return RusotoError::Service(
ModifyClusterError::ClusterParameterGroupNotFoundFault(
parsed_error.message,
),
)
}
"ClusterSecurityGroupNotFound" => {
return RusotoError::Service(
ModifyClusterError::ClusterSecurityGroupNotFoundFault(
parsed_error.message,
),
)
}
"DependentServiceRequestThrottlingFault" => {
return RusotoError::Service(
ModifyClusterError::DependentServiceRequestThrottlingFault(
parsed_error.message,
),
)
}
"HsmClientCertificateNotFoundFault" => {
return RusotoError::Service(
ModifyClusterError::HsmClientCertificateNotFoundFault(
parsed_error.message,
),
)
}
"HsmConfigurationNotFoundFault" => {
return RusotoError::Service(
ModifyClusterError::HsmConfigurationNotFoundFault(parsed_error.message),
)
}
"InsufficientClusterCapacity" => {
return RusotoError::Service(
ModifyClusterError::InsufficientClusterCapacityFault(
parsed_error.message,
),
)
}
"InvalidClusterSecurityGroupState" => {
return RusotoError::Service(
ModifyClusterError::InvalidClusterSecurityGroupStateFault(
parsed_error.message,
),
)
}
"InvalidClusterState" => {
return RusotoError::Service(ModifyClusterError::InvalidClusterStateFault(
parsed_error.message,
))
}
"InvalidClusterTrack" => {
return RusotoError::Service(ModifyClusterError::InvalidClusterTrackFault(
parsed_error.message,
))
}
"InvalidElasticIpFault" => {
return RusotoError::Service(ModifyClusterError::InvalidElasticIpFault(
parsed_error.message,
))
}
"InvalidRetentionPeriodFault" => {
return RusotoError::Service(
ModifyClusterError::InvalidRetentionPeriodFault(parsed_error.message),
)
}
"LimitExceededFault" => {
return RusotoError::Service(ModifyClusterError::LimitExceededFault(
parsed_error.message,
))
}
"NumberOfNodesPerClusterLimitExceeded" => {
return RusotoError::Service(
ModifyClusterError::NumberOfNodesPerClusterLimitExceededFault(
parsed_error.message,
),
)
}
"NumberOfNodesQuotaExceeded" => {
return RusotoError::Service(
ModifyClusterError::NumberOfNodesQuotaExceededFault(
parsed_error.message,
),
)
}
"TableLimitExceeded" => {
return RusotoError::Service(ModifyClusterError::TableLimitExceededFault(
parsed_error.message,
))
}
"UnauthorizedOperation" => {
return RusotoError::Service(ModifyClusterError::UnauthorizedOperation(
parsed_error.message,
))
}
"UnsupportedOptionFault" => {
return RusotoError::Service(ModifyClusterError::UnsupportedOptionFault(
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 ModifyClusterError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ModifyClusterError::ClusterAlreadyExistsFault(ref cause) => write!(f, "{}", cause),
ModifyClusterError::ClusterNotFoundFault(ref cause) => write!(f, "{}", cause),
ModifyClusterError::ClusterParameterGroupNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
ModifyClusterError::ClusterSecurityGroupNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
ModifyClusterError::DependentServiceRequestThrottlingFault(ref cause) => {
write!(f, "{}", cause)
}
ModifyClusterError::HsmClientCertificateNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
ModifyClusterError::HsmConfigurationNotFoundFault(ref cause) => write!(f, "{}", cause),
ModifyClusterError::InsufficientClusterCapacityFault(ref cause) => {
write!(f, "{}", cause)
}
ModifyClusterError::InvalidClusterSecurityGroupStateFault(ref cause) => {
write!(f, "{}", cause)
}
ModifyClusterError::InvalidClusterStateFault(ref cause) => write!(f, "{}", cause),
ModifyClusterError::InvalidClusterTrackFault(ref cause) => write!(f, "{}", cause),
ModifyClusterError::InvalidElasticIpFault(ref cause) => write!(f, "{}", cause),
ModifyClusterError::InvalidRetentionPeriodFault(ref cause) => write!(f, "{}", cause),
ModifyClusterError::LimitExceededFault(ref cause) => write!(f, "{}", cause),
ModifyClusterError::NumberOfNodesPerClusterLimitExceededFault(ref cause) => {
write!(f, "{}", cause)
}
ModifyClusterError::NumberOfNodesQuotaExceededFault(ref cause) => {
write!(f, "{}", cause)
}
ModifyClusterError::TableLimitExceededFault(ref cause) => write!(f, "{}", cause),
ModifyClusterError::UnauthorizedOperation(ref cause) => write!(f, "{}", cause),
ModifyClusterError::UnsupportedOptionFault(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ModifyClusterError {}
#[derive(Debug, PartialEq)]
pub enum ModifyClusterDbRevisionError {
ClusterNotFoundFault(String),
ClusterOnLatestRevisionFault(String),
InvalidClusterStateFault(String),
}
impl ModifyClusterDbRevisionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ModifyClusterDbRevisionError> {
{
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[..] {
"ClusterNotFound" => {
return RusotoError::Service(
ModifyClusterDbRevisionError::ClusterNotFoundFault(
parsed_error.message,
),
)
}
"ClusterOnLatestRevision" => {
return RusotoError::Service(
ModifyClusterDbRevisionError::ClusterOnLatestRevisionFault(
parsed_error.message,
),
)
}
"InvalidClusterState" => {
return RusotoError::Service(
ModifyClusterDbRevisionError::InvalidClusterStateFault(
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 ModifyClusterDbRevisionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ModifyClusterDbRevisionError::ClusterNotFoundFault(ref cause) => write!(f, "{}", cause),
ModifyClusterDbRevisionError::ClusterOnLatestRevisionFault(ref cause) => {
write!(f, "{}", cause)
}
ModifyClusterDbRevisionError::InvalidClusterStateFault(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for ModifyClusterDbRevisionError {}
#[derive(Debug, PartialEq)]
pub enum ModifyClusterIamRolesError {
ClusterNotFoundFault(String),
InvalidClusterStateFault(String),
}
impl ModifyClusterIamRolesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ModifyClusterIamRolesError> {
{
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[..] {
"ClusterNotFound" => {
return RusotoError::Service(
ModifyClusterIamRolesError::ClusterNotFoundFault(parsed_error.message),
)
}
"InvalidClusterState" => {
return RusotoError::Service(
ModifyClusterIamRolesError::InvalidClusterStateFault(
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 ModifyClusterIamRolesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ModifyClusterIamRolesError::ClusterNotFoundFault(ref cause) => write!(f, "{}", cause),
ModifyClusterIamRolesError::InvalidClusterStateFault(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for ModifyClusterIamRolesError {}
#[derive(Debug, PartialEq)]
pub enum ModifyClusterMaintenanceError {
ClusterNotFoundFault(String),
InvalidClusterStateFault(String),
}
impl ModifyClusterMaintenanceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ModifyClusterMaintenanceError> {
{
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[..] {
"ClusterNotFound" => {
return RusotoError::Service(
ModifyClusterMaintenanceError::ClusterNotFoundFault(
parsed_error.message,
),
)
}
"InvalidClusterState" => {
return RusotoError::Service(
ModifyClusterMaintenanceError::InvalidClusterStateFault(
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 ModifyClusterMaintenanceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ModifyClusterMaintenanceError::ClusterNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
ModifyClusterMaintenanceError::InvalidClusterStateFault(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for ModifyClusterMaintenanceError {}
#[derive(Debug, PartialEq)]
pub enum ModifyClusterParameterGroupError {
ClusterParameterGroupNotFoundFault(String),
InvalidClusterParameterGroupStateFault(String),
}
impl ModifyClusterParameterGroupError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ModifyClusterParameterGroupError> {
{
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[..] {
"ClusterParameterGroupNotFound" => {
return RusotoError::Service(
ModifyClusterParameterGroupError::ClusterParameterGroupNotFoundFault(
parsed_error.message,
),
)
}
"InvalidClusterParameterGroupState" => return RusotoError::Service(
ModifyClusterParameterGroupError::InvalidClusterParameterGroupStateFault(
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 ModifyClusterParameterGroupError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ModifyClusterParameterGroupError::ClusterParameterGroupNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
ModifyClusterParameterGroupError::InvalidClusterParameterGroupStateFault(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for ModifyClusterParameterGroupError {}
#[derive(Debug, PartialEq)]
pub enum ModifyClusterSnapshotError {
ClusterSnapshotNotFoundFault(String),
InvalidClusterSnapshotStateFault(String),
InvalidRetentionPeriodFault(String),
}
impl ModifyClusterSnapshotError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ModifyClusterSnapshotError> {
{
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[..] {
"ClusterSnapshotNotFound" => {
return RusotoError::Service(
ModifyClusterSnapshotError::ClusterSnapshotNotFoundFault(
parsed_error.message,
),
)
}
"InvalidClusterSnapshotState" => {
return RusotoError::Service(
ModifyClusterSnapshotError::InvalidClusterSnapshotStateFault(
parsed_error.message,
),
)
}
"InvalidRetentionPeriodFault" => {
return RusotoError::Service(
ModifyClusterSnapshotError::InvalidRetentionPeriodFault(
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 ModifyClusterSnapshotError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ModifyClusterSnapshotError::ClusterSnapshotNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
ModifyClusterSnapshotError::InvalidClusterSnapshotStateFault(ref cause) => {
write!(f, "{}", cause)
}
ModifyClusterSnapshotError::InvalidRetentionPeriodFault(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for ModifyClusterSnapshotError {}
#[derive(Debug, PartialEq)]
pub enum ModifyClusterSnapshotScheduleError {
ClusterNotFoundFault(String),
InvalidClusterSnapshotScheduleStateFault(String),
SnapshotScheduleNotFoundFault(String),
}
impl ModifyClusterSnapshotScheduleError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ModifyClusterSnapshotScheduleError> {
{
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[..] {
"ClusterNotFound" => return RusotoError::Service(ModifyClusterSnapshotScheduleError::ClusterNotFoundFault(parsed_error.message)),"InvalidClusterSnapshotScheduleState" => return RusotoError::Service(ModifyClusterSnapshotScheduleError::InvalidClusterSnapshotScheduleStateFault(parsed_error.message)),"SnapshotScheduleNotFound" => return RusotoError::Service(ModifyClusterSnapshotScheduleError::SnapshotScheduleNotFoundFault(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 ModifyClusterSnapshotScheduleError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ModifyClusterSnapshotScheduleError::ClusterNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
ModifyClusterSnapshotScheduleError::InvalidClusterSnapshotScheduleStateFault(
ref cause,
) => write!(f, "{}", cause),
ModifyClusterSnapshotScheduleError::SnapshotScheduleNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for ModifyClusterSnapshotScheduleError {}
#[derive(Debug, PartialEq)]
pub enum ModifyClusterSubnetGroupError {
ClusterSubnetGroupNotFoundFault(String),
ClusterSubnetQuotaExceededFault(String),
DependentServiceRequestThrottlingFault(String),
InvalidSubnet(String),
SubnetAlreadyInUse(String),
UnauthorizedOperation(String),
}
impl ModifyClusterSubnetGroupError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ModifyClusterSubnetGroupError> {
{
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[..] {
"ClusterSubnetGroupNotFoundFault" => {
return RusotoError::Service(
ModifyClusterSubnetGroupError::ClusterSubnetGroupNotFoundFault(
parsed_error.message,
),
)
}
"ClusterSubnetQuotaExceededFault" => {
return RusotoError::Service(
ModifyClusterSubnetGroupError::ClusterSubnetQuotaExceededFault(
parsed_error.message,
),
)
}
"DependentServiceRequestThrottlingFault" => {
return RusotoError::Service(
ModifyClusterSubnetGroupError::DependentServiceRequestThrottlingFault(
parsed_error.message,
),
)
}
"InvalidSubnet" => {
return RusotoError::Service(ModifyClusterSubnetGroupError::InvalidSubnet(
parsed_error.message,
))
}
"SubnetAlreadyInUse" => {
return RusotoError::Service(
ModifyClusterSubnetGroupError::SubnetAlreadyInUse(parsed_error.message),
)
}
"UnauthorizedOperation" => {
return RusotoError::Service(
ModifyClusterSubnetGroupError::UnauthorizedOperation(
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 ModifyClusterSubnetGroupError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ModifyClusterSubnetGroupError::ClusterSubnetGroupNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
ModifyClusterSubnetGroupError::ClusterSubnetQuotaExceededFault(ref cause) => {
write!(f, "{}", cause)
}
ModifyClusterSubnetGroupError::DependentServiceRequestThrottlingFault(ref cause) => {
write!(f, "{}", cause)
}
ModifyClusterSubnetGroupError::InvalidSubnet(ref cause) => write!(f, "{}", cause),
ModifyClusterSubnetGroupError::SubnetAlreadyInUse(ref cause) => write!(f, "{}", cause),
ModifyClusterSubnetGroupError::UnauthorizedOperation(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for ModifyClusterSubnetGroupError {}
#[derive(Debug, PartialEq)]
pub enum ModifyEventSubscriptionError {
InvalidSubscriptionStateFault(String),
SNSInvalidTopicFault(String),
SNSNoAuthorizationFault(String),
SNSTopicArnNotFoundFault(String),
SourceNotFoundFault(String),
SubscriptionCategoryNotFoundFault(String),
SubscriptionEventIdNotFoundFault(String),
SubscriptionNotFoundFault(String),
SubscriptionSeverityNotFoundFault(String),
}
impl ModifyEventSubscriptionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ModifyEventSubscriptionError> {
{
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[..] {
"InvalidSubscriptionStateFault" => {
return RusotoError::Service(
ModifyEventSubscriptionError::InvalidSubscriptionStateFault(
parsed_error.message,
),
)
}
"SNSInvalidTopic" => {
return RusotoError::Service(
ModifyEventSubscriptionError::SNSInvalidTopicFault(
parsed_error.message,
),
)
}
"SNSNoAuthorization" => {
return RusotoError::Service(
ModifyEventSubscriptionError::SNSNoAuthorizationFault(
parsed_error.message,
),
)
}
"SNSTopicArnNotFound" => {
return RusotoError::Service(
ModifyEventSubscriptionError::SNSTopicArnNotFoundFault(
parsed_error.message,
),
)
}
"SourceNotFound" => {
return RusotoError::Service(
ModifyEventSubscriptionError::SourceNotFoundFault(parsed_error.message),
)
}
"SubscriptionCategoryNotFound" => {
return RusotoError::Service(
ModifyEventSubscriptionError::SubscriptionCategoryNotFoundFault(
parsed_error.message,
),
)
}
"SubscriptionEventIdNotFound" => {
return RusotoError::Service(
ModifyEventSubscriptionError::SubscriptionEventIdNotFoundFault(
parsed_error.message,
),
)
}
"SubscriptionNotFound" => {
return RusotoError::Service(
ModifyEventSubscriptionError::SubscriptionNotFoundFault(
parsed_error.message,
),
)
}
"SubscriptionSeverityNotFound" => {
return RusotoError::Service(
ModifyEventSubscriptionError::SubscriptionSeverityNotFoundFault(
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 ModifyEventSubscriptionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ModifyEventSubscriptionError::InvalidSubscriptionStateFault(ref cause) => {
write!(f, "{}", cause)
}
ModifyEventSubscriptionError::SNSInvalidTopicFault(ref cause) => write!(f, "{}", cause),
ModifyEventSubscriptionError::SNSNoAuthorizationFault(ref cause) => {
write!(f, "{}", cause)
}
ModifyEventSubscriptionError::SNSTopicArnNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
ModifyEventSubscriptionError::SourceNotFoundFault(ref cause) => write!(f, "{}", cause),
ModifyEventSubscriptionError::SubscriptionCategoryNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
ModifyEventSubscriptionError::SubscriptionEventIdNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
ModifyEventSubscriptionError::SubscriptionNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
ModifyEventSubscriptionError::SubscriptionSeverityNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for ModifyEventSubscriptionError {}
#[derive(Debug, PartialEq)]
pub enum ModifyScheduledActionError {
InvalidScheduleFault(String),
InvalidScheduledActionFault(String),
ScheduledActionNotFoundFault(String),
ScheduledActionTypeUnsupportedFault(String),
UnauthorizedOperation(String),
}
impl ModifyScheduledActionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ModifyScheduledActionError> {
{
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[..] {
"InvalidSchedule" => {
return RusotoError::Service(
ModifyScheduledActionError::InvalidScheduleFault(parsed_error.message),
)
}
"InvalidScheduledAction" => {
return RusotoError::Service(
ModifyScheduledActionError::InvalidScheduledActionFault(
parsed_error.message,
),
)
}
"ScheduledActionNotFound" => {
return RusotoError::Service(
ModifyScheduledActionError::ScheduledActionNotFoundFault(
parsed_error.message,
),
)
}
"ScheduledActionTypeUnsupported" => {
return RusotoError::Service(
ModifyScheduledActionError::ScheduledActionTypeUnsupportedFault(
parsed_error.message,
),
)
}
"UnauthorizedOperation" => {
return RusotoError::Service(
ModifyScheduledActionError::UnauthorizedOperation(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 ModifyScheduledActionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ModifyScheduledActionError::InvalidScheduleFault(ref cause) => write!(f, "{}", cause),
ModifyScheduledActionError::InvalidScheduledActionFault(ref cause) => {
write!(f, "{}", cause)
}
ModifyScheduledActionError::ScheduledActionNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
ModifyScheduledActionError::ScheduledActionTypeUnsupportedFault(ref cause) => {
write!(f, "{}", cause)
}
ModifyScheduledActionError::UnauthorizedOperation(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ModifyScheduledActionError {}
#[derive(Debug, PartialEq)]
pub enum ModifySnapshotCopyRetentionPeriodError {
ClusterNotFoundFault(String),
InvalidClusterStateFault(String),
InvalidRetentionPeriodFault(String),
SnapshotCopyDisabledFault(String),
UnauthorizedOperation(String),
}
impl ModifySnapshotCopyRetentionPeriodError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ModifySnapshotCopyRetentionPeriodError> {
{
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[..] {
"ClusterNotFound" => {
return RusotoError::Service(
ModifySnapshotCopyRetentionPeriodError::ClusterNotFoundFault(
parsed_error.message,
),
)
}
"InvalidClusterState" => {
return RusotoError::Service(
ModifySnapshotCopyRetentionPeriodError::InvalidClusterStateFault(
parsed_error.message,
),
)
}
"InvalidRetentionPeriodFault" => {
return RusotoError::Service(
ModifySnapshotCopyRetentionPeriodError::InvalidRetentionPeriodFault(
parsed_error.message,
),
)
}
"SnapshotCopyDisabledFault" => {
return RusotoError::Service(
ModifySnapshotCopyRetentionPeriodError::SnapshotCopyDisabledFault(
parsed_error.message,
),
)
}
"UnauthorizedOperation" => {
return RusotoError::Service(
ModifySnapshotCopyRetentionPeriodError::UnauthorizedOperation(
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 ModifySnapshotCopyRetentionPeriodError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ModifySnapshotCopyRetentionPeriodError::ClusterNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
ModifySnapshotCopyRetentionPeriodError::InvalidClusterStateFault(ref cause) => {
write!(f, "{}", cause)
}
ModifySnapshotCopyRetentionPeriodError::InvalidRetentionPeriodFault(ref cause) => {
write!(f, "{}", cause)
}
ModifySnapshotCopyRetentionPeriodError::SnapshotCopyDisabledFault(ref cause) => {
write!(f, "{}", cause)
}
ModifySnapshotCopyRetentionPeriodError::UnauthorizedOperation(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for ModifySnapshotCopyRetentionPeriodError {}
#[derive(Debug, PartialEq)]
pub enum ModifySnapshotScheduleError {
InvalidScheduleFault(String),
SnapshotScheduleNotFoundFault(String),
SnapshotScheduleUpdateInProgressFault(String),
}
impl ModifySnapshotScheduleError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ModifySnapshotScheduleError> {
{
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[..] {
"InvalidSchedule" => {
return RusotoError::Service(
ModifySnapshotScheduleError::InvalidScheduleFault(parsed_error.message),
)
}
"SnapshotScheduleNotFound" => {
return RusotoError::Service(
ModifySnapshotScheduleError::SnapshotScheduleNotFoundFault(
parsed_error.message,
),
)
}
"SnapshotScheduleUpdateInProgress" => {
return RusotoError::Service(
ModifySnapshotScheduleError::SnapshotScheduleUpdateInProgressFault(
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 ModifySnapshotScheduleError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ModifySnapshotScheduleError::InvalidScheduleFault(ref cause) => write!(f, "{}", cause),
ModifySnapshotScheduleError::SnapshotScheduleNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
ModifySnapshotScheduleError::SnapshotScheduleUpdateInProgressFault(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for ModifySnapshotScheduleError {}
#[derive(Debug, PartialEq)]
pub enum ModifyUsageLimitError {
InvalidUsageLimitFault(String),
UnsupportedOperationFault(String),
UsageLimitNotFoundFault(String),
}
impl ModifyUsageLimitError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ModifyUsageLimitError> {
{
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[..] {
"InvalidUsageLimit" => {
return RusotoError::Service(ModifyUsageLimitError::InvalidUsageLimitFault(
parsed_error.message,
))
}
"UnsupportedOperation" => {
return RusotoError::Service(
ModifyUsageLimitError::UnsupportedOperationFault(parsed_error.message),
)
}
"UsageLimitNotFound" => {
return RusotoError::Service(
ModifyUsageLimitError::UsageLimitNotFoundFault(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 ModifyUsageLimitError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ModifyUsageLimitError::InvalidUsageLimitFault(ref cause) => write!(f, "{}", cause),
ModifyUsageLimitError::UnsupportedOperationFault(ref cause) => write!(f, "{}", cause),
ModifyUsageLimitError::UsageLimitNotFoundFault(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ModifyUsageLimitError {}
#[derive(Debug, PartialEq)]
pub enum PauseClusterError {
ClusterNotFoundFault(String),
InvalidClusterStateFault(String),
}
impl PauseClusterError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<PauseClusterError> {
{
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[..] {
"ClusterNotFound" => {
return RusotoError::Service(PauseClusterError::ClusterNotFoundFault(
parsed_error.message,
))
}
"InvalidClusterState" => {
return RusotoError::Service(PauseClusterError::InvalidClusterStateFault(
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 PauseClusterError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
PauseClusterError::ClusterNotFoundFault(ref cause) => write!(f, "{}", cause),
PauseClusterError::InvalidClusterStateFault(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for PauseClusterError {}
#[derive(Debug, PartialEq)]
pub enum PurchaseReservedNodeOfferingError {
ReservedNodeAlreadyExistsFault(String),
ReservedNodeOfferingNotFoundFault(String),
ReservedNodeQuotaExceededFault(String),
UnsupportedOperationFault(String),
}
impl PurchaseReservedNodeOfferingError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<PurchaseReservedNodeOfferingError> {
{
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[..] {
"ReservedNodeAlreadyExists" => {
return RusotoError::Service(
PurchaseReservedNodeOfferingError::ReservedNodeAlreadyExistsFault(
parsed_error.message,
),
)
}
"ReservedNodeOfferingNotFound" => {
return RusotoError::Service(
PurchaseReservedNodeOfferingError::ReservedNodeOfferingNotFoundFault(
parsed_error.message,
),
)
}
"ReservedNodeQuotaExceeded" => {
return RusotoError::Service(
PurchaseReservedNodeOfferingError::ReservedNodeQuotaExceededFault(
parsed_error.message,
),
)
}
"UnsupportedOperation" => {
return RusotoError::Service(
PurchaseReservedNodeOfferingError::UnsupportedOperationFault(
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 PurchaseReservedNodeOfferingError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
PurchaseReservedNodeOfferingError::ReservedNodeAlreadyExistsFault(ref cause) => {
write!(f, "{}", cause)
}
PurchaseReservedNodeOfferingError::ReservedNodeOfferingNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
PurchaseReservedNodeOfferingError::ReservedNodeQuotaExceededFault(ref cause) => {
write!(f, "{}", cause)
}
PurchaseReservedNodeOfferingError::UnsupportedOperationFault(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for PurchaseReservedNodeOfferingError {}
#[derive(Debug, PartialEq)]
pub enum RebootClusterError {
ClusterNotFoundFault(String),
InvalidClusterStateFault(String),
}
impl RebootClusterError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<RebootClusterError> {
{
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[..] {
"ClusterNotFound" => {
return RusotoError::Service(RebootClusterError::ClusterNotFoundFault(
parsed_error.message,
))
}
"InvalidClusterState" => {
return RusotoError::Service(RebootClusterError::InvalidClusterStateFault(
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 RebootClusterError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
RebootClusterError::ClusterNotFoundFault(ref cause) => write!(f, "{}", cause),
RebootClusterError::InvalidClusterStateFault(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for RebootClusterError {}
#[derive(Debug, PartialEq)]
pub enum ResetClusterParameterGroupError {
ClusterParameterGroupNotFoundFault(String),
InvalidClusterParameterGroupStateFault(String),
}
impl ResetClusterParameterGroupError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ResetClusterParameterGroupError> {
{
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[..] {
"ClusterParameterGroupNotFound" => {
return RusotoError::Service(
ResetClusterParameterGroupError::ClusterParameterGroupNotFoundFault(
parsed_error.message,
),
)
}
"InvalidClusterParameterGroupState" => {
return RusotoError::Service(
ResetClusterParameterGroupError::InvalidClusterParameterGroupStateFault(
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 ResetClusterParameterGroupError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ResetClusterParameterGroupError::ClusterParameterGroupNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
ResetClusterParameterGroupError::InvalidClusterParameterGroupStateFault(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for ResetClusterParameterGroupError {}
#[derive(Debug, PartialEq)]
pub enum ResizeClusterError {
ClusterNotFoundFault(String),
InsufficientClusterCapacityFault(String),
InvalidClusterStateFault(String),
LimitExceededFault(String),
NumberOfNodesPerClusterLimitExceededFault(String),
NumberOfNodesQuotaExceededFault(String),
UnauthorizedOperation(String),
UnsupportedOperationFault(String),
UnsupportedOptionFault(String),
}
impl ResizeClusterError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ResizeClusterError> {
{
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[..] {
"ClusterNotFound" => {
return RusotoError::Service(ResizeClusterError::ClusterNotFoundFault(
parsed_error.message,
))
}
"InsufficientClusterCapacity" => {
return RusotoError::Service(
ResizeClusterError::InsufficientClusterCapacityFault(
parsed_error.message,
),
)
}
"InvalidClusterState" => {
return RusotoError::Service(ResizeClusterError::InvalidClusterStateFault(
parsed_error.message,
))
}
"LimitExceededFault" => {
return RusotoError::Service(ResizeClusterError::LimitExceededFault(
parsed_error.message,
))
}
"NumberOfNodesPerClusterLimitExceeded" => {
return RusotoError::Service(
ResizeClusterError::NumberOfNodesPerClusterLimitExceededFault(
parsed_error.message,
),
)
}
"NumberOfNodesQuotaExceeded" => {
return RusotoError::Service(
ResizeClusterError::NumberOfNodesQuotaExceededFault(
parsed_error.message,
),
)
}
"UnauthorizedOperation" => {
return RusotoError::Service(ResizeClusterError::UnauthorizedOperation(
parsed_error.message,
))
}
"UnsupportedOperation" => {
return RusotoError::Service(ResizeClusterError::UnsupportedOperationFault(
parsed_error.message,
))
}
"UnsupportedOptionFault" => {
return RusotoError::Service(ResizeClusterError::UnsupportedOptionFault(
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 ResizeClusterError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ResizeClusterError::ClusterNotFoundFault(ref cause) => write!(f, "{}", cause),
ResizeClusterError::InsufficientClusterCapacityFault(ref cause) => {
write!(f, "{}", cause)
}
ResizeClusterError::InvalidClusterStateFault(ref cause) => write!(f, "{}", cause),
ResizeClusterError::LimitExceededFault(ref cause) => write!(f, "{}", cause),
ResizeClusterError::NumberOfNodesPerClusterLimitExceededFault(ref cause) => {
write!(f, "{}", cause)
}
ResizeClusterError::NumberOfNodesQuotaExceededFault(ref cause) => {
write!(f, "{}", cause)
}
ResizeClusterError::UnauthorizedOperation(ref cause) => write!(f, "{}", cause),
ResizeClusterError::UnsupportedOperationFault(ref cause) => write!(f, "{}", cause),
ResizeClusterError::UnsupportedOptionFault(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ResizeClusterError {}
#[derive(Debug, PartialEq)]
pub enum RestoreFromClusterSnapshotError {
AccessToSnapshotDeniedFault(String),
ClusterAlreadyExistsFault(String),
ClusterParameterGroupNotFoundFault(String),
ClusterQuotaExceededFault(String),
ClusterSecurityGroupNotFoundFault(String),
ClusterSnapshotNotFoundFault(String),
ClusterSubnetGroupNotFoundFault(String),
DependentServiceRequestThrottlingFault(String),
HsmClientCertificateNotFoundFault(String),
HsmConfigurationNotFoundFault(String),
InsufficientClusterCapacityFault(String),
InvalidClusterSnapshotStateFault(String),
InvalidClusterSubnetGroupStateFault(String),
InvalidClusterTrackFault(String),
InvalidElasticIpFault(String),
InvalidRestoreFault(String),
InvalidSubnet(String),
InvalidTagFault(String),
InvalidVPCNetworkStateFault(String),
LimitExceededFault(String),
NumberOfNodesPerClusterLimitExceededFault(String),
NumberOfNodesQuotaExceededFault(String),
SnapshotScheduleNotFoundFault(String),
TagLimitExceededFault(String),
UnauthorizedOperation(String),
}
impl RestoreFromClusterSnapshotError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<RestoreFromClusterSnapshotError> {
{
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[..] {
"AccessToSnapshotDenied" => {
return RusotoError::Service(
RestoreFromClusterSnapshotError::AccessToSnapshotDeniedFault(
parsed_error.message,
),
)
}
"ClusterAlreadyExists" => {
return RusotoError::Service(
RestoreFromClusterSnapshotError::ClusterAlreadyExistsFault(
parsed_error.message,
),
)
}
"ClusterParameterGroupNotFound" => {
return RusotoError::Service(
RestoreFromClusterSnapshotError::ClusterParameterGroupNotFoundFault(
parsed_error.message,
),
)
}
"ClusterQuotaExceeded" => {
return RusotoError::Service(
RestoreFromClusterSnapshotError::ClusterQuotaExceededFault(
parsed_error.message,
),
)
}
"ClusterSecurityGroupNotFound" => {
return RusotoError::Service(
RestoreFromClusterSnapshotError::ClusterSecurityGroupNotFoundFault(
parsed_error.message,
),
)
}
"ClusterSnapshotNotFound" => {
return RusotoError::Service(
RestoreFromClusterSnapshotError::ClusterSnapshotNotFoundFault(
parsed_error.message,
),
)
}
"ClusterSubnetGroupNotFoundFault" => {
return RusotoError::Service(
RestoreFromClusterSnapshotError::ClusterSubnetGroupNotFoundFault(
parsed_error.message,
),
)
}
"DependentServiceRequestThrottlingFault" => {
return RusotoError::Service(
RestoreFromClusterSnapshotError::DependentServiceRequestThrottlingFault(
parsed_error.message,
),
)
}
"HsmClientCertificateNotFoundFault" => {
return RusotoError::Service(
RestoreFromClusterSnapshotError::HsmClientCertificateNotFoundFault(
parsed_error.message,
),
)
}
"HsmConfigurationNotFoundFault" => {
return RusotoError::Service(
RestoreFromClusterSnapshotError::HsmConfigurationNotFoundFault(
parsed_error.message,
),
)
}
"InsufficientClusterCapacity" => {
return RusotoError::Service(
RestoreFromClusterSnapshotError::InsufficientClusterCapacityFault(
parsed_error.message,
),
)
}
"InvalidClusterSnapshotState" => {
return RusotoError::Service(
RestoreFromClusterSnapshotError::InvalidClusterSnapshotStateFault(
parsed_error.message,
),
)
}
"InvalidClusterSubnetGroupStateFault" => {
return RusotoError::Service(
RestoreFromClusterSnapshotError::InvalidClusterSubnetGroupStateFault(
parsed_error.message,
),
)
}
"InvalidClusterTrack" => {
return RusotoError::Service(
RestoreFromClusterSnapshotError::InvalidClusterTrackFault(
parsed_error.message,
),
)
}
"InvalidElasticIpFault" => {
return RusotoError::Service(
RestoreFromClusterSnapshotError::InvalidElasticIpFault(
parsed_error.message,
),
)
}
"InvalidRestore" => {
return RusotoError::Service(
RestoreFromClusterSnapshotError::InvalidRestoreFault(
parsed_error.message,
),
)
}
"InvalidSubnet" => {
return RusotoError::Service(
RestoreFromClusterSnapshotError::InvalidSubnet(parsed_error.message),
)
}
"InvalidTagFault" => {
return RusotoError::Service(
RestoreFromClusterSnapshotError::InvalidTagFault(parsed_error.message),
)
}
"InvalidVPCNetworkStateFault" => {
return RusotoError::Service(
RestoreFromClusterSnapshotError::InvalidVPCNetworkStateFault(
parsed_error.message,
),
)
}
"LimitExceededFault" => {
return RusotoError::Service(
RestoreFromClusterSnapshotError::LimitExceededFault(
parsed_error.message,
),
)
}
"NumberOfNodesPerClusterLimitExceeded" => return RusotoError::Service(
RestoreFromClusterSnapshotError::NumberOfNodesPerClusterLimitExceededFault(
parsed_error.message,
),
),
"NumberOfNodesQuotaExceeded" => {
return RusotoError::Service(
RestoreFromClusterSnapshotError::NumberOfNodesQuotaExceededFault(
parsed_error.message,
),
)
}
"SnapshotScheduleNotFound" => {
return RusotoError::Service(
RestoreFromClusterSnapshotError::SnapshotScheduleNotFoundFault(
parsed_error.message,
),
)
}
"TagLimitExceededFault" => {
return RusotoError::Service(
RestoreFromClusterSnapshotError::TagLimitExceededFault(
parsed_error.message,
),
)
}
"UnauthorizedOperation" => {
return RusotoError::Service(
RestoreFromClusterSnapshotError::UnauthorizedOperation(
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 RestoreFromClusterSnapshotError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
RestoreFromClusterSnapshotError::AccessToSnapshotDeniedFault(ref cause) => {
write!(f, "{}", cause)
}
RestoreFromClusterSnapshotError::ClusterAlreadyExistsFault(ref cause) => {
write!(f, "{}", cause)
}
RestoreFromClusterSnapshotError::ClusterParameterGroupNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
RestoreFromClusterSnapshotError::ClusterQuotaExceededFault(ref cause) => {
write!(f, "{}", cause)
}
RestoreFromClusterSnapshotError::ClusterSecurityGroupNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
RestoreFromClusterSnapshotError::ClusterSnapshotNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
RestoreFromClusterSnapshotError::ClusterSubnetGroupNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
RestoreFromClusterSnapshotError::DependentServiceRequestThrottlingFault(ref cause) => {
write!(f, "{}", cause)
}
RestoreFromClusterSnapshotError::HsmClientCertificateNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
RestoreFromClusterSnapshotError::HsmConfigurationNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
RestoreFromClusterSnapshotError::InsufficientClusterCapacityFault(ref cause) => {
write!(f, "{}", cause)
}
RestoreFromClusterSnapshotError::InvalidClusterSnapshotStateFault(ref cause) => {
write!(f, "{}", cause)
}
RestoreFromClusterSnapshotError::InvalidClusterSubnetGroupStateFault(ref cause) => {
write!(f, "{}", cause)
}
RestoreFromClusterSnapshotError::InvalidClusterTrackFault(ref cause) => {
write!(f, "{}", cause)
}
RestoreFromClusterSnapshotError::InvalidElasticIpFault(ref cause) => {
write!(f, "{}", cause)
}
RestoreFromClusterSnapshotError::InvalidRestoreFault(ref cause) => {
write!(f, "{}", cause)
}
RestoreFromClusterSnapshotError::InvalidSubnet(ref cause) => write!(f, "{}", cause),
RestoreFromClusterSnapshotError::InvalidTagFault(ref cause) => write!(f, "{}", cause),
RestoreFromClusterSnapshotError::InvalidVPCNetworkStateFault(ref cause) => {
write!(f, "{}", cause)
}
RestoreFromClusterSnapshotError::LimitExceededFault(ref cause) => {
write!(f, "{}", cause)
}
RestoreFromClusterSnapshotError::NumberOfNodesPerClusterLimitExceededFault(
ref cause,
) => write!(f, "{}", cause),
RestoreFromClusterSnapshotError::NumberOfNodesQuotaExceededFault(ref cause) => {
write!(f, "{}", cause)
}
RestoreFromClusterSnapshotError::SnapshotScheduleNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
RestoreFromClusterSnapshotError::TagLimitExceededFault(ref cause) => {
write!(f, "{}", cause)
}
RestoreFromClusterSnapshotError::UnauthorizedOperation(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for RestoreFromClusterSnapshotError {}
#[derive(Debug, PartialEq)]
pub enum RestoreTableFromClusterSnapshotError {
ClusterNotFoundFault(String),
ClusterSnapshotNotFoundFault(String),
InProgressTableRestoreQuotaExceededFault(String),
InvalidClusterSnapshotStateFault(String),
InvalidClusterStateFault(String),
InvalidTableRestoreArgumentFault(String),
UnsupportedOperationFault(String),
}
impl RestoreTableFromClusterSnapshotError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<RestoreTableFromClusterSnapshotError> {
{
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[..] {
"ClusterNotFound" => return RusotoError::Service(RestoreTableFromClusterSnapshotError::ClusterNotFoundFault(parsed_error.message)),"ClusterSnapshotNotFound" => return RusotoError::Service(RestoreTableFromClusterSnapshotError::ClusterSnapshotNotFoundFault(parsed_error.message)),"InProgressTableRestoreQuotaExceededFault" => return RusotoError::Service(RestoreTableFromClusterSnapshotError::InProgressTableRestoreQuotaExceededFault(parsed_error.message)),"InvalidClusterSnapshotState" => return RusotoError::Service(RestoreTableFromClusterSnapshotError::InvalidClusterSnapshotStateFault(parsed_error.message)),"InvalidClusterState" => return RusotoError::Service(RestoreTableFromClusterSnapshotError::InvalidClusterStateFault(parsed_error.message)),"InvalidTableRestoreArgument" => return RusotoError::Service(RestoreTableFromClusterSnapshotError::InvalidTableRestoreArgumentFault(parsed_error.message)),"UnsupportedOperation" => return RusotoError::Service(RestoreTableFromClusterSnapshotError::UnsupportedOperationFault(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 RestoreTableFromClusterSnapshotError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
RestoreTableFromClusterSnapshotError::ClusterNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
RestoreTableFromClusterSnapshotError::ClusterSnapshotNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
RestoreTableFromClusterSnapshotError::InProgressTableRestoreQuotaExceededFault(
ref cause,
) => write!(f, "{}", cause),
RestoreTableFromClusterSnapshotError::InvalidClusterSnapshotStateFault(ref cause) => {
write!(f, "{}", cause)
}
RestoreTableFromClusterSnapshotError::InvalidClusterStateFault(ref cause) => {
write!(f, "{}", cause)
}
RestoreTableFromClusterSnapshotError::InvalidTableRestoreArgumentFault(ref cause) => {
write!(f, "{}", cause)
}
RestoreTableFromClusterSnapshotError::UnsupportedOperationFault(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for RestoreTableFromClusterSnapshotError {}
#[derive(Debug, PartialEq)]
pub enum ResumeClusterError {
ClusterNotFoundFault(String),
InvalidClusterStateFault(String),
}
impl ResumeClusterError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ResumeClusterError> {
{
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[..] {
"ClusterNotFound" => {
return RusotoError::Service(ResumeClusterError::ClusterNotFoundFault(
parsed_error.message,
))
}
"InvalidClusterState" => {
return RusotoError::Service(ResumeClusterError::InvalidClusterStateFault(
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 ResumeClusterError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ResumeClusterError::ClusterNotFoundFault(ref cause) => write!(f, "{}", cause),
ResumeClusterError::InvalidClusterStateFault(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ResumeClusterError {}
#[derive(Debug, PartialEq)]
pub enum RevokeClusterSecurityGroupIngressError {
AuthorizationNotFoundFault(String),
ClusterSecurityGroupNotFoundFault(String),
InvalidClusterSecurityGroupStateFault(String),
}
impl RevokeClusterSecurityGroupIngressError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<RevokeClusterSecurityGroupIngressError> {
{
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[..] {
"AuthorizationNotFound" => return RusotoError::Service(RevokeClusterSecurityGroupIngressError::AuthorizationNotFoundFault(parsed_error.message)),"ClusterSecurityGroupNotFound" => return RusotoError::Service(RevokeClusterSecurityGroupIngressError::ClusterSecurityGroupNotFoundFault(parsed_error.message)),"InvalidClusterSecurityGroupState" => return RusotoError::Service(RevokeClusterSecurityGroupIngressError::InvalidClusterSecurityGroupStateFault(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 RevokeClusterSecurityGroupIngressError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
RevokeClusterSecurityGroupIngressError::AuthorizationNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
RevokeClusterSecurityGroupIngressError::ClusterSecurityGroupNotFoundFault(
ref cause,
) => write!(f, "{}", cause),
RevokeClusterSecurityGroupIngressError::InvalidClusterSecurityGroupStateFault(
ref cause,
) => write!(f, "{}", cause),
}
}
}
impl Error for RevokeClusterSecurityGroupIngressError {}
#[derive(Debug, PartialEq)]
pub enum RevokeSnapshotAccessError {
AccessToSnapshotDeniedFault(String),
AuthorizationNotFoundFault(String),
ClusterSnapshotNotFoundFault(String),
}
impl RevokeSnapshotAccessError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<RevokeSnapshotAccessError> {
{
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[..] {
"AccessToSnapshotDenied" => {
return RusotoError::Service(
RevokeSnapshotAccessError::AccessToSnapshotDeniedFault(
parsed_error.message,
),
)
}
"AuthorizationNotFound" => {
return RusotoError::Service(
RevokeSnapshotAccessError::AuthorizationNotFoundFault(
parsed_error.message,
),
)
}
"ClusterSnapshotNotFound" => {
return RusotoError::Service(
RevokeSnapshotAccessError::ClusterSnapshotNotFoundFault(
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 RevokeSnapshotAccessError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
RevokeSnapshotAccessError::AccessToSnapshotDeniedFault(ref cause) => {
write!(f, "{}", cause)
}
RevokeSnapshotAccessError::AuthorizationNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
RevokeSnapshotAccessError::ClusterSnapshotNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for RevokeSnapshotAccessError {}
#[derive(Debug, PartialEq)]
pub enum RotateEncryptionKeyError {
ClusterNotFoundFault(String),
DependentServiceRequestThrottlingFault(String),
InvalidClusterStateFault(String),
}
impl RotateEncryptionKeyError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<RotateEncryptionKeyError> {
{
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[..] {
"ClusterNotFound" => {
return RusotoError::Service(
RotateEncryptionKeyError::ClusterNotFoundFault(parsed_error.message),
)
}
"DependentServiceRequestThrottlingFault" => {
return RusotoError::Service(
RotateEncryptionKeyError::DependentServiceRequestThrottlingFault(
parsed_error.message,
),
)
}
"InvalidClusterState" => {
return RusotoError::Service(
RotateEncryptionKeyError::InvalidClusterStateFault(
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 RotateEncryptionKeyError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
RotateEncryptionKeyError::ClusterNotFoundFault(ref cause) => write!(f, "{}", cause),
RotateEncryptionKeyError::DependentServiceRequestThrottlingFault(ref cause) => {
write!(f, "{}", cause)
}
RotateEncryptionKeyError::InvalidClusterStateFault(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for RotateEncryptionKeyError {}
#[async_trait]
pub trait Redshift {
async fn accept_reserved_node_exchange(
&self,
input: AcceptReservedNodeExchangeInputMessage,
) -> Result<AcceptReservedNodeExchangeOutputMessage, RusotoError<AcceptReservedNodeExchangeError>>;
async fn authorize_cluster_security_group_ingress(
&self,
input: AuthorizeClusterSecurityGroupIngressMessage,
) -> Result<
AuthorizeClusterSecurityGroupIngressResult,
RusotoError<AuthorizeClusterSecurityGroupIngressError>,
>;
async fn authorize_snapshot_access(
&self,
input: AuthorizeSnapshotAccessMessage,
) -> Result<AuthorizeSnapshotAccessResult, RusotoError<AuthorizeSnapshotAccessError>>;
async fn batch_delete_cluster_snapshots(
&self,
input: BatchDeleteClusterSnapshotsRequest,
) -> Result<BatchDeleteClusterSnapshotsResult, RusotoError<BatchDeleteClusterSnapshotsError>>;
async fn batch_modify_cluster_snapshots(
&self,
input: BatchModifyClusterSnapshotsMessage,
) -> Result<
BatchModifyClusterSnapshotsOutputMessage,
RusotoError<BatchModifyClusterSnapshotsError>,
>;
async fn cancel_resize(
&self,
input: CancelResizeMessage,
) -> Result<ResizeProgressMessage, RusotoError<CancelResizeError>>;
async fn copy_cluster_snapshot(
&self,
input: CopyClusterSnapshotMessage,
) -> Result<CopyClusterSnapshotResult, RusotoError<CopyClusterSnapshotError>>;
async fn create_cluster(
&self,
input: CreateClusterMessage,
) -> Result<CreateClusterResult, RusotoError<CreateClusterError>>;
async fn create_cluster_parameter_group(
&self,
input: CreateClusterParameterGroupMessage,
) -> Result<CreateClusterParameterGroupResult, RusotoError<CreateClusterParameterGroupError>>;
async fn create_cluster_security_group(
&self,
input: CreateClusterSecurityGroupMessage,
) -> Result<CreateClusterSecurityGroupResult, RusotoError<CreateClusterSecurityGroupError>>;
async fn create_cluster_snapshot(
&self,
input: CreateClusterSnapshotMessage,
) -> Result<CreateClusterSnapshotResult, RusotoError<CreateClusterSnapshotError>>;
async fn create_cluster_subnet_group(
&self,
input: CreateClusterSubnetGroupMessage,
) -> Result<CreateClusterSubnetGroupResult, RusotoError<CreateClusterSubnetGroupError>>;
async fn create_event_subscription(
&self,
input: CreateEventSubscriptionMessage,
) -> Result<CreateEventSubscriptionResult, RusotoError<CreateEventSubscriptionError>>;
async fn create_hsm_client_certificate(
&self,
input: CreateHsmClientCertificateMessage,
) -> Result<CreateHsmClientCertificateResult, RusotoError<CreateHsmClientCertificateError>>;
async fn create_hsm_configuration(
&self,
input: CreateHsmConfigurationMessage,
) -> Result<CreateHsmConfigurationResult, RusotoError<CreateHsmConfigurationError>>;
async fn create_scheduled_action(
&self,
input: CreateScheduledActionMessage,
) -> Result<ScheduledAction, RusotoError<CreateScheduledActionError>>;
async fn create_snapshot_copy_grant(
&self,
input: CreateSnapshotCopyGrantMessage,
) -> Result<CreateSnapshotCopyGrantResult, RusotoError<CreateSnapshotCopyGrantError>>;
async fn create_snapshot_schedule(
&self,
input: CreateSnapshotScheduleMessage,
) -> Result<SnapshotSchedule, RusotoError<CreateSnapshotScheduleError>>;
async fn create_tags(
&self,
input: CreateTagsMessage,
) -> Result<(), RusotoError<CreateTagsError>>;
async fn create_usage_limit(
&self,
input: CreateUsageLimitMessage,
) -> Result<UsageLimit, RusotoError<CreateUsageLimitError>>;
async fn delete_cluster(
&self,
input: DeleteClusterMessage,
) -> Result<DeleteClusterResult, RusotoError<DeleteClusterError>>;
async fn delete_cluster_parameter_group(
&self,
input: DeleteClusterParameterGroupMessage,
) -> Result<(), RusotoError<DeleteClusterParameterGroupError>>;
async fn delete_cluster_security_group(
&self,
input: DeleteClusterSecurityGroupMessage,
) -> Result<(), RusotoError<DeleteClusterSecurityGroupError>>;
async fn delete_cluster_snapshot(
&self,
input: DeleteClusterSnapshotMessage,
) -> Result<DeleteClusterSnapshotResult, RusotoError<DeleteClusterSnapshotError>>;
async fn delete_cluster_subnet_group(
&self,
input: DeleteClusterSubnetGroupMessage,
) -> Result<(), RusotoError<DeleteClusterSubnetGroupError>>;
async fn delete_event_subscription(
&self,
input: DeleteEventSubscriptionMessage,
) -> Result<(), RusotoError<DeleteEventSubscriptionError>>;
async fn delete_hsm_client_certificate(
&self,
input: DeleteHsmClientCertificateMessage,
) -> Result<(), RusotoError<DeleteHsmClientCertificateError>>;
async fn delete_hsm_configuration(
&self,
input: DeleteHsmConfigurationMessage,
) -> Result<(), RusotoError<DeleteHsmConfigurationError>>;
async fn delete_scheduled_action(
&self,
input: DeleteScheduledActionMessage,
) -> Result<(), RusotoError<DeleteScheduledActionError>>;
async fn delete_snapshot_copy_grant(
&self,
input: DeleteSnapshotCopyGrantMessage,
) -> Result<(), RusotoError<DeleteSnapshotCopyGrantError>>;
async fn delete_snapshot_schedule(
&self,
input: DeleteSnapshotScheduleMessage,
) -> Result<(), RusotoError<DeleteSnapshotScheduleError>>;
async fn delete_tags(
&self,
input: DeleteTagsMessage,
) -> Result<(), RusotoError<DeleteTagsError>>;
async fn delete_usage_limit(
&self,
input: DeleteUsageLimitMessage,
) -> Result<(), RusotoError<DeleteUsageLimitError>>;
async fn describe_account_attributes(
&self,
input: DescribeAccountAttributesMessage,
) -> Result<AccountAttributeList, RusotoError<DescribeAccountAttributesError>>;
async fn describe_cluster_db_revisions(
&self,
input: DescribeClusterDbRevisionsMessage,
) -> Result<ClusterDbRevisionsMessage, RusotoError<DescribeClusterDbRevisionsError>>;
async fn describe_cluster_parameter_groups(
&self,
input: DescribeClusterParameterGroupsMessage,
) -> Result<ClusterParameterGroupsMessage, RusotoError<DescribeClusterParameterGroupsError>>;
async fn describe_cluster_parameters(
&self,
input: DescribeClusterParametersMessage,
) -> Result<ClusterParameterGroupDetails, RusotoError<DescribeClusterParametersError>>;
async fn describe_cluster_security_groups(
&self,
input: DescribeClusterSecurityGroupsMessage,
) -> Result<ClusterSecurityGroupMessage, RusotoError<DescribeClusterSecurityGroupsError>>;
async fn describe_cluster_snapshots(
&self,
input: DescribeClusterSnapshotsMessage,
) -> Result<SnapshotMessage, RusotoError<DescribeClusterSnapshotsError>>;
async fn describe_cluster_subnet_groups(
&self,
input: DescribeClusterSubnetGroupsMessage,
) -> Result<ClusterSubnetGroupMessage, RusotoError<DescribeClusterSubnetGroupsError>>;
async fn describe_cluster_tracks(
&self,
input: DescribeClusterTracksMessage,
) -> Result<TrackListMessage, RusotoError<DescribeClusterTracksError>>;
async fn describe_cluster_versions(
&self,
input: DescribeClusterVersionsMessage,
) -> Result<ClusterVersionsMessage, RusotoError<DescribeClusterVersionsError>>;
async fn describe_clusters(
&self,
input: DescribeClustersMessage,
) -> Result<ClustersMessage, RusotoError<DescribeClustersError>>;
async fn describe_default_cluster_parameters(
&self,
input: DescribeDefaultClusterParametersMessage,
) -> Result<
DescribeDefaultClusterParametersResult,
RusotoError<DescribeDefaultClusterParametersError>,
>;
async fn describe_event_categories(
&self,
input: DescribeEventCategoriesMessage,
) -> Result<EventCategoriesMessage, RusotoError<DescribeEventCategoriesError>>;
async fn describe_event_subscriptions(
&self,
input: DescribeEventSubscriptionsMessage,
) -> Result<EventSubscriptionsMessage, RusotoError<DescribeEventSubscriptionsError>>;
async fn describe_events(
&self,
input: DescribeEventsMessage,
) -> Result<EventsMessage, RusotoError<DescribeEventsError>>;
async fn describe_hsm_client_certificates(
&self,
input: DescribeHsmClientCertificatesMessage,
) -> Result<HsmClientCertificateMessage, RusotoError<DescribeHsmClientCertificatesError>>;
async fn describe_hsm_configurations(
&self,
input: DescribeHsmConfigurationsMessage,
) -> Result<HsmConfigurationMessage, RusotoError<DescribeHsmConfigurationsError>>;
async fn describe_logging_status(
&self,
input: DescribeLoggingStatusMessage,
) -> Result<LoggingStatus, RusotoError<DescribeLoggingStatusError>>;
async fn describe_node_configuration_options(
&self,
input: DescribeNodeConfigurationOptionsMessage,
) -> Result<NodeConfigurationOptionsMessage, RusotoError<DescribeNodeConfigurationOptionsError>>;
async fn describe_orderable_cluster_options(
&self,
input: DescribeOrderableClusterOptionsMessage,
) -> Result<OrderableClusterOptionsMessage, RusotoError<DescribeOrderableClusterOptionsError>>;
async fn describe_reserved_node_offerings(
&self,
input: DescribeReservedNodeOfferingsMessage,
) -> Result<ReservedNodeOfferingsMessage, RusotoError<DescribeReservedNodeOfferingsError>>;
async fn describe_reserved_nodes(
&self,
input: DescribeReservedNodesMessage,
) -> Result<ReservedNodesMessage, RusotoError<DescribeReservedNodesError>>;
async fn describe_resize(
&self,
input: DescribeResizeMessage,
) -> Result<ResizeProgressMessage, RusotoError<DescribeResizeError>>;
async fn describe_scheduled_actions(
&self,
input: DescribeScheduledActionsMessage,
) -> Result<ScheduledActionsMessage, RusotoError<DescribeScheduledActionsError>>;
async fn describe_snapshot_copy_grants(
&self,
input: DescribeSnapshotCopyGrantsMessage,
) -> Result<SnapshotCopyGrantMessage, RusotoError<DescribeSnapshotCopyGrantsError>>;
async fn describe_snapshot_schedules(
&self,
input: DescribeSnapshotSchedulesMessage,
) -> Result<DescribeSnapshotSchedulesOutputMessage, RusotoError<DescribeSnapshotSchedulesError>>;
async fn describe_storage(
&self,
) -> Result<CustomerStorageMessage, RusotoError<DescribeStorageError>>;
async fn describe_table_restore_status(
&self,
input: DescribeTableRestoreStatusMessage,
) -> Result<TableRestoreStatusMessage, RusotoError<DescribeTableRestoreStatusError>>;
async fn describe_tags(
&self,
input: DescribeTagsMessage,
) -> Result<TaggedResourceListMessage, RusotoError<DescribeTagsError>>;
async fn describe_usage_limits(
&self,
input: DescribeUsageLimitsMessage,
) -> Result<UsageLimitList, RusotoError<DescribeUsageLimitsError>>;
async fn disable_logging(
&self,
input: DisableLoggingMessage,
) -> Result<LoggingStatus, RusotoError<DisableLoggingError>>;
async fn disable_snapshot_copy(
&self,
input: DisableSnapshotCopyMessage,
) -> Result<DisableSnapshotCopyResult, RusotoError<DisableSnapshotCopyError>>;
async fn enable_logging(
&self,
input: EnableLoggingMessage,
) -> Result<LoggingStatus, RusotoError<EnableLoggingError>>;
async fn enable_snapshot_copy(
&self,
input: EnableSnapshotCopyMessage,
) -> Result<EnableSnapshotCopyResult, RusotoError<EnableSnapshotCopyError>>;
async fn get_cluster_credentials(
&self,
input: GetClusterCredentialsMessage,
) -> Result<ClusterCredentials, RusotoError<GetClusterCredentialsError>>;
async fn get_reserved_node_exchange_offerings(
&self,
input: GetReservedNodeExchangeOfferingsInputMessage,
) -> Result<
GetReservedNodeExchangeOfferingsOutputMessage,
RusotoError<GetReservedNodeExchangeOfferingsError>,
>;
async fn modify_cluster(
&self,
input: ModifyClusterMessage,
) -> Result<ModifyClusterResult, RusotoError<ModifyClusterError>>;
async fn modify_cluster_db_revision(
&self,
input: ModifyClusterDbRevisionMessage,
) -> Result<ModifyClusterDbRevisionResult, RusotoError<ModifyClusterDbRevisionError>>;
async fn modify_cluster_iam_roles(
&self,
input: ModifyClusterIamRolesMessage,
) -> Result<ModifyClusterIamRolesResult, RusotoError<ModifyClusterIamRolesError>>;
async fn modify_cluster_maintenance(
&self,
input: ModifyClusterMaintenanceMessage,
) -> Result<ModifyClusterMaintenanceResult, RusotoError<ModifyClusterMaintenanceError>>;
async fn modify_cluster_parameter_group(
&self,
input: ModifyClusterParameterGroupMessage,
) -> Result<ClusterParameterGroupNameMessage, RusotoError<ModifyClusterParameterGroupError>>;
async fn modify_cluster_snapshot(
&self,
input: ModifyClusterSnapshotMessage,
) -> Result<ModifyClusterSnapshotResult, RusotoError<ModifyClusterSnapshotError>>;
async fn modify_cluster_snapshot_schedule(
&self,
input: ModifyClusterSnapshotScheduleMessage,
) -> Result<(), RusotoError<ModifyClusterSnapshotScheduleError>>;
async fn modify_cluster_subnet_group(
&self,
input: ModifyClusterSubnetGroupMessage,
) -> Result<ModifyClusterSubnetGroupResult, RusotoError<ModifyClusterSubnetGroupError>>;
async fn modify_event_subscription(
&self,
input: ModifyEventSubscriptionMessage,
) -> Result<ModifyEventSubscriptionResult, RusotoError<ModifyEventSubscriptionError>>;
async fn modify_scheduled_action(
&self,
input: ModifyScheduledActionMessage,
) -> Result<ScheduledAction, RusotoError<ModifyScheduledActionError>>;
async fn modify_snapshot_copy_retention_period(
&self,
input: ModifySnapshotCopyRetentionPeriodMessage,
) -> Result<
ModifySnapshotCopyRetentionPeriodResult,
RusotoError<ModifySnapshotCopyRetentionPeriodError>,
>;
async fn modify_snapshot_schedule(
&self,
input: ModifySnapshotScheduleMessage,
) -> Result<SnapshotSchedule, RusotoError<ModifySnapshotScheduleError>>;
async fn modify_usage_limit(
&self,
input: ModifyUsageLimitMessage,
) -> Result<UsageLimit, RusotoError<ModifyUsageLimitError>>;
async fn pause_cluster(
&self,
input: PauseClusterMessage,
) -> Result<PauseClusterResult, RusotoError<PauseClusterError>>;
async fn purchase_reserved_node_offering(
&self,
input: PurchaseReservedNodeOfferingMessage,
) -> Result<PurchaseReservedNodeOfferingResult, RusotoError<PurchaseReservedNodeOfferingError>>;
async fn reboot_cluster(
&self,
input: RebootClusterMessage,
) -> Result<RebootClusterResult, RusotoError<RebootClusterError>>;
async fn reset_cluster_parameter_group(
&self,
input: ResetClusterParameterGroupMessage,
) -> Result<ClusterParameterGroupNameMessage, RusotoError<ResetClusterParameterGroupError>>;
async fn resize_cluster(
&self,
input: ResizeClusterMessage,
) -> Result<ResizeClusterResult, RusotoError<ResizeClusterError>>;
async fn restore_from_cluster_snapshot(
&self,
input: RestoreFromClusterSnapshotMessage,
) -> Result<RestoreFromClusterSnapshotResult, RusotoError<RestoreFromClusterSnapshotError>>;
async fn restore_table_from_cluster_snapshot(
&self,
input: RestoreTableFromClusterSnapshotMessage,
) -> Result<
RestoreTableFromClusterSnapshotResult,
RusotoError<RestoreTableFromClusterSnapshotError>,
>;
async fn resume_cluster(
&self,
input: ResumeClusterMessage,
) -> Result<ResumeClusterResult, RusotoError<ResumeClusterError>>;
async fn revoke_cluster_security_group_ingress(
&self,
input: RevokeClusterSecurityGroupIngressMessage,
) -> Result<
RevokeClusterSecurityGroupIngressResult,
RusotoError<RevokeClusterSecurityGroupIngressError>,
>;
async fn revoke_snapshot_access(
&self,
input: RevokeSnapshotAccessMessage,
) -> Result<RevokeSnapshotAccessResult, RusotoError<RevokeSnapshotAccessError>>;
async fn rotate_encryption_key(
&self,
input: RotateEncryptionKeyMessage,
) -> Result<RotateEncryptionKeyResult, RusotoError<RotateEncryptionKeyError>>;
}
#[derive(Clone)]
pub struct RedshiftClient {
client: Client,
region: region::Region,
}
impl RedshiftClient {
pub fn new(region: region::Region) -> RedshiftClient {
RedshiftClient {
client: Client::shared(),
region,
}
}
pub fn new_with<P, D>(
request_dispatcher: D,
credentials_provider: P,
region: region::Region,
) -> RedshiftClient
where
P: ProvideAwsCredentials + Send + Sync + 'static,
D: DispatchSignedRequest + Send + Sync + 'static,
{
RedshiftClient {
client: Client::new_with(credentials_provider, request_dispatcher),
region,
}
}
pub fn new_with_client(client: Client, region: region::Region) -> RedshiftClient {
RedshiftClient { client, region }
}
}
#[async_trait]
impl Redshift for RedshiftClient {
async fn accept_reserved_node_exchange(
&self,
input: AcceptReservedNodeExchangeInputMessage,
) -> Result<AcceptReservedNodeExchangeOutputMessage, RusotoError<AcceptReservedNodeExchangeError>>
{
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let params = self.new_params("AcceptReservedNodeExchange");
let mut params = params;
AcceptReservedNodeExchangeInputMessageSerializer::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, AcceptReservedNodeExchangeError::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 = AcceptReservedNodeExchangeOutputMessageDeserializer::deserialize(
"AcceptReservedNodeExchangeResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn authorize_cluster_security_group_ingress(
&self,
input: AuthorizeClusterSecurityGroupIngressMessage,
) -> Result<
AuthorizeClusterSecurityGroupIngressResult,
RusotoError<AuthorizeClusterSecurityGroupIngressError>,
> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let params = self.new_params("AuthorizeClusterSecurityGroupIngress");
let mut params = params;
AuthorizeClusterSecurityGroupIngressMessageSerializer::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,
AuthorizeClusterSecurityGroupIngressError::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 = AuthorizeClusterSecurityGroupIngressResultDeserializer::deserialize(
"AuthorizeClusterSecurityGroupIngressResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn authorize_snapshot_access(
&self,
input: AuthorizeSnapshotAccessMessage,
) -> Result<AuthorizeSnapshotAccessResult, RusotoError<AuthorizeSnapshotAccessError>> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let params = self.new_params("AuthorizeSnapshotAccess");
let mut params = params;
AuthorizeSnapshotAccessMessageSerializer::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, AuthorizeSnapshotAccessError::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 = AuthorizeSnapshotAccessResultDeserializer::deserialize(
"AuthorizeSnapshotAccessResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn batch_delete_cluster_snapshots(
&self,
input: BatchDeleteClusterSnapshotsRequest,
) -> Result<BatchDeleteClusterSnapshotsResult, RusotoError<BatchDeleteClusterSnapshotsError>>
{
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let params = self.new_params("BatchDeleteClusterSnapshots");
let mut params = params;
BatchDeleteClusterSnapshotsRequestSerializer::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, BatchDeleteClusterSnapshotsError::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 = BatchDeleteClusterSnapshotsResultDeserializer::deserialize(
"BatchDeleteClusterSnapshotsResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn batch_modify_cluster_snapshots(
&self,
input: BatchModifyClusterSnapshotsMessage,
) -> Result<
BatchModifyClusterSnapshotsOutputMessage,
RusotoError<BatchModifyClusterSnapshotsError>,
> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let params = self.new_params("BatchModifyClusterSnapshots");
let mut params = params;
BatchModifyClusterSnapshotsMessageSerializer::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, BatchModifyClusterSnapshotsError::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 = BatchModifyClusterSnapshotsOutputMessageDeserializer::deserialize(
"BatchModifyClusterSnapshotsResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn cancel_resize(
&self,
input: CancelResizeMessage,
) -> Result<ResizeProgressMessage, RusotoError<CancelResizeError>> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let params = self.new_params("CancelResize");
let mut params = params;
CancelResizeMessageSerializer::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, CancelResizeError::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 =
ResizeProgressMessageDeserializer::deserialize("CancelResizeResult", stack)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn copy_cluster_snapshot(
&self,
input: CopyClusterSnapshotMessage,
) -> Result<CopyClusterSnapshotResult, RusotoError<CopyClusterSnapshotError>> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let params = self.new_params("CopyClusterSnapshot");
let mut params = params;
CopyClusterSnapshotMessageSerializer::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, CopyClusterSnapshotError::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 = CopyClusterSnapshotResultDeserializer::deserialize(
"CopyClusterSnapshotResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn create_cluster(
&self,
input: CreateClusterMessage,
) -> Result<CreateClusterResult, RusotoError<CreateClusterError>> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let params = self.new_params("CreateCluster");
let mut params = params;
CreateClusterMessageSerializer::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, CreateClusterError::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 =
CreateClusterResultDeserializer::deserialize("CreateClusterResult", stack)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn create_cluster_parameter_group(
&self,
input: CreateClusterParameterGroupMessage,
) -> Result<CreateClusterParameterGroupResult, RusotoError<CreateClusterParameterGroupError>>
{
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let params = self.new_params("CreateClusterParameterGroup");
let mut params = params;
CreateClusterParameterGroupMessageSerializer::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, CreateClusterParameterGroupError::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 = CreateClusterParameterGroupResultDeserializer::deserialize(
"CreateClusterParameterGroupResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn create_cluster_security_group(
&self,
input: CreateClusterSecurityGroupMessage,
) -> Result<CreateClusterSecurityGroupResult, RusotoError<CreateClusterSecurityGroupError>>
{
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let params = self.new_params("CreateClusterSecurityGroup");
let mut params = params;
CreateClusterSecurityGroupMessageSerializer::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, CreateClusterSecurityGroupError::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 = CreateClusterSecurityGroupResultDeserializer::deserialize(
"CreateClusterSecurityGroupResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn create_cluster_snapshot(
&self,
input: CreateClusterSnapshotMessage,
) -> Result<CreateClusterSnapshotResult, RusotoError<CreateClusterSnapshotError>> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let params = self.new_params("CreateClusterSnapshot");
let mut params = params;
CreateClusterSnapshotMessageSerializer::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, CreateClusterSnapshotError::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 = CreateClusterSnapshotResultDeserializer::deserialize(
"CreateClusterSnapshotResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn create_cluster_subnet_group(
&self,
input: CreateClusterSubnetGroupMessage,
) -> Result<CreateClusterSubnetGroupResult, RusotoError<CreateClusterSubnetGroupError>> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let params = self.new_params("CreateClusterSubnetGroup");
let mut params = params;
CreateClusterSubnetGroupMessageSerializer::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, CreateClusterSubnetGroupError::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 = CreateClusterSubnetGroupResultDeserializer::deserialize(
"CreateClusterSubnetGroupResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn create_event_subscription(
&self,
input: CreateEventSubscriptionMessage,
) -> Result<CreateEventSubscriptionResult, RusotoError<CreateEventSubscriptionError>> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let params = self.new_params("CreateEventSubscription");
let mut params = params;
CreateEventSubscriptionMessageSerializer::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, CreateEventSubscriptionError::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 = CreateEventSubscriptionResultDeserializer::deserialize(
"CreateEventSubscriptionResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn create_hsm_client_certificate(
&self,
input: CreateHsmClientCertificateMessage,
) -> Result<CreateHsmClientCertificateResult, RusotoError<CreateHsmClientCertificateError>>
{
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let params = self.new_params("CreateHsmClientCertificate");
let mut params = params;
CreateHsmClientCertificateMessageSerializer::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, CreateHsmClientCertificateError::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 = CreateHsmClientCertificateResultDeserializer::deserialize(
"CreateHsmClientCertificateResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn create_hsm_configuration(
&self,
input: CreateHsmConfigurationMessage,
) -> Result<CreateHsmConfigurationResult, RusotoError<CreateHsmConfigurationError>> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let params = self.new_params("CreateHsmConfiguration");
let mut params = params;
CreateHsmConfigurationMessageSerializer::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, CreateHsmConfigurationError::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 = CreateHsmConfigurationResultDeserializer::deserialize(
"CreateHsmConfigurationResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn create_scheduled_action(
&self,
input: CreateScheduledActionMessage,
) -> Result<ScheduledAction, RusotoError<CreateScheduledActionError>> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let params = self.new_params("CreateScheduledAction");
let mut params = params;
CreateScheduledActionMessageSerializer::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, CreateScheduledActionError::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 =
ScheduledActionDeserializer::deserialize("CreateScheduledActionResult", stack)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn create_snapshot_copy_grant(
&self,
input: CreateSnapshotCopyGrantMessage,
) -> Result<CreateSnapshotCopyGrantResult, RusotoError<CreateSnapshotCopyGrantError>> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let params = self.new_params("CreateSnapshotCopyGrant");
let mut params = params;
CreateSnapshotCopyGrantMessageSerializer::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, CreateSnapshotCopyGrantError::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 = CreateSnapshotCopyGrantResultDeserializer::deserialize(
"CreateSnapshotCopyGrantResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn create_snapshot_schedule(
&self,
input: CreateSnapshotScheduleMessage,
) -> Result<SnapshotSchedule, RusotoError<CreateSnapshotScheduleError>> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let params = self.new_params("CreateSnapshotSchedule");
let mut params = params;
CreateSnapshotScheduleMessageSerializer::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, CreateSnapshotScheduleError::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 =
SnapshotScheduleDeserializer::deserialize("CreateSnapshotScheduleResult", stack)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn create_tags(
&self,
input: CreateTagsMessage,
) -> Result<(), RusotoError<CreateTagsError>> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let params = self.new_params("CreateTags");
let mut params = params;
CreateTagsMessageSerializer::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, CreateTagsError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
async fn create_usage_limit(
&self,
input: CreateUsageLimitMessage,
) -> Result<UsageLimit, RusotoError<CreateUsageLimitError>> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let params = self.new_params("CreateUsageLimit");
let mut params = params;
CreateUsageLimitMessageSerializer::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, CreateUsageLimitError::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 = UsageLimitDeserializer::deserialize("CreateUsageLimitResult", stack)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn delete_cluster(
&self,
input: DeleteClusterMessage,
) -> Result<DeleteClusterResult, RusotoError<DeleteClusterError>> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let params = self.new_params("DeleteCluster");
let mut params = params;
DeleteClusterMessageSerializer::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, DeleteClusterError::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 =
DeleteClusterResultDeserializer::deserialize("DeleteClusterResult", stack)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn delete_cluster_parameter_group(
&self,
input: DeleteClusterParameterGroupMessage,
) -> Result<(), RusotoError<DeleteClusterParameterGroupError>> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let params = self.new_params("DeleteClusterParameterGroup");
let mut params = params;
DeleteClusterParameterGroupMessageSerializer::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, DeleteClusterParameterGroupError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
async fn delete_cluster_security_group(
&self,
input: DeleteClusterSecurityGroupMessage,
) -> Result<(), RusotoError<DeleteClusterSecurityGroupError>> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let params = self.new_params("DeleteClusterSecurityGroup");
let mut params = params;
DeleteClusterSecurityGroupMessageSerializer::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, DeleteClusterSecurityGroupError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
async fn delete_cluster_snapshot(
&self,
input: DeleteClusterSnapshotMessage,
) -> Result<DeleteClusterSnapshotResult, RusotoError<DeleteClusterSnapshotError>> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let params = self.new_params("DeleteClusterSnapshot");
let mut params = params;
DeleteClusterSnapshotMessageSerializer::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, DeleteClusterSnapshotError::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 = DeleteClusterSnapshotResultDeserializer::deserialize(
"DeleteClusterSnapshotResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn delete_cluster_subnet_group(
&self,
input: DeleteClusterSubnetGroupMessage,
) -> Result<(), RusotoError<DeleteClusterSubnetGroupError>> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let params = self.new_params("DeleteClusterSubnetGroup");
let mut params = params;
DeleteClusterSubnetGroupMessageSerializer::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, DeleteClusterSubnetGroupError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
async fn delete_event_subscription(
&self,
input: DeleteEventSubscriptionMessage,
) -> Result<(), RusotoError<DeleteEventSubscriptionError>> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let params = self.new_params("DeleteEventSubscription");
let mut params = params;
DeleteEventSubscriptionMessageSerializer::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, DeleteEventSubscriptionError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
async fn delete_hsm_client_certificate(
&self,
input: DeleteHsmClientCertificateMessage,
) -> Result<(), RusotoError<DeleteHsmClientCertificateError>> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let params = self.new_params("DeleteHsmClientCertificate");
let mut params = params;
DeleteHsmClientCertificateMessageSerializer::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, DeleteHsmClientCertificateError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
async fn delete_hsm_configuration(
&self,
input: DeleteHsmConfigurationMessage,
) -> Result<(), RusotoError<DeleteHsmConfigurationError>> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let params = self.new_params("DeleteHsmConfiguration");
let mut params = params;
DeleteHsmConfigurationMessageSerializer::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, DeleteHsmConfigurationError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
async fn delete_scheduled_action(
&self,
input: DeleteScheduledActionMessage,
) -> Result<(), RusotoError<DeleteScheduledActionError>> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let params = self.new_params("DeleteScheduledAction");
let mut params = params;
DeleteScheduledActionMessageSerializer::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, DeleteScheduledActionError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
async fn delete_snapshot_copy_grant(
&self,
input: DeleteSnapshotCopyGrantMessage,
) -> Result<(), RusotoError<DeleteSnapshotCopyGrantError>> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let params = self.new_params("DeleteSnapshotCopyGrant");
let mut params = params;
DeleteSnapshotCopyGrantMessageSerializer::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, DeleteSnapshotCopyGrantError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
async fn delete_snapshot_schedule(
&self,
input: DeleteSnapshotScheduleMessage,
) -> Result<(), RusotoError<DeleteSnapshotScheduleError>> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let params = self.new_params("DeleteSnapshotSchedule");
let mut params = params;
DeleteSnapshotScheduleMessageSerializer::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, DeleteSnapshotScheduleError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
async fn delete_tags(
&self,
input: DeleteTagsMessage,
) -> Result<(), RusotoError<DeleteTagsError>> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let params = self.new_params("DeleteTags");
let mut params = params;
DeleteTagsMessageSerializer::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, DeleteTagsError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
async fn delete_usage_limit(
&self,
input: DeleteUsageLimitMessage,
) -> Result<(), RusotoError<DeleteUsageLimitError>> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let params = self.new_params("DeleteUsageLimit");
let mut params = params;
DeleteUsageLimitMessageSerializer::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, DeleteUsageLimitError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
async fn describe_account_attributes(
&self,
input: DescribeAccountAttributesMessage,
) -> Result<AccountAttributeList, RusotoError<DescribeAccountAttributesError>> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let params = self.new_params("DescribeAccountAttributes");
let mut params = params;
DescribeAccountAttributesMessageSerializer::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, DescribeAccountAttributesError::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 = AccountAttributeListDeserializer::deserialize(
"DescribeAccountAttributesResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn describe_cluster_db_revisions(
&self,
input: DescribeClusterDbRevisionsMessage,
) -> Result<ClusterDbRevisionsMessage, RusotoError<DescribeClusterDbRevisionsError>> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let params = self.new_params("DescribeClusterDbRevisions");
let mut params = params;
DescribeClusterDbRevisionsMessageSerializer::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, DescribeClusterDbRevisionsError::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 = ClusterDbRevisionsMessageDeserializer::deserialize(
"DescribeClusterDbRevisionsResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn describe_cluster_parameter_groups(
&self,
input: DescribeClusterParameterGroupsMessage,
) -> Result<ClusterParameterGroupsMessage, RusotoError<DescribeClusterParameterGroupsError>>
{
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let params = self.new_params("DescribeClusterParameterGroups");
let mut params = params;
DescribeClusterParameterGroupsMessageSerializer::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, DescribeClusterParameterGroupsError::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 = ClusterParameterGroupsMessageDeserializer::deserialize(
"DescribeClusterParameterGroupsResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn describe_cluster_parameters(
&self,
input: DescribeClusterParametersMessage,
) -> Result<ClusterParameterGroupDetails, RusotoError<DescribeClusterParametersError>> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let params = self.new_params("DescribeClusterParameters");
let mut params = params;
DescribeClusterParametersMessageSerializer::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, DescribeClusterParametersError::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 = ClusterParameterGroupDetailsDeserializer::deserialize(
"DescribeClusterParametersResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn describe_cluster_security_groups(
&self,
input: DescribeClusterSecurityGroupsMessage,
) -> Result<ClusterSecurityGroupMessage, RusotoError<DescribeClusterSecurityGroupsError>> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let params = self.new_params("DescribeClusterSecurityGroups");
let mut params = params;
DescribeClusterSecurityGroupsMessageSerializer::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, DescribeClusterSecurityGroupsError::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 = ClusterSecurityGroupMessageDeserializer::deserialize(
"DescribeClusterSecurityGroupsResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn describe_cluster_snapshots(
&self,
input: DescribeClusterSnapshotsMessage,
) -> Result<SnapshotMessage, RusotoError<DescribeClusterSnapshotsError>> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let params = self.new_params("DescribeClusterSnapshots");
let mut params = params;
DescribeClusterSnapshotsMessageSerializer::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, DescribeClusterSnapshotsError::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 =
SnapshotMessageDeserializer::deserialize("DescribeClusterSnapshotsResult", stack)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn describe_cluster_subnet_groups(
&self,
input: DescribeClusterSubnetGroupsMessage,
) -> Result<ClusterSubnetGroupMessage, RusotoError<DescribeClusterSubnetGroupsError>> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let params = self.new_params("DescribeClusterSubnetGroups");
let mut params = params;
DescribeClusterSubnetGroupsMessageSerializer::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, DescribeClusterSubnetGroupsError::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 = ClusterSubnetGroupMessageDeserializer::deserialize(
"DescribeClusterSubnetGroupsResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn describe_cluster_tracks(
&self,
input: DescribeClusterTracksMessage,
) -> Result<TrackListMessage, RusotoError<DescribeClusterTracksError>> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let params = self.new_params("DescribeClusterTracks");
let mut params = params;
DescribeClusterTracksMessageSerializer::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, DescribeClusterTracksError::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 =
TrackListMessageDeserializer::deserialize("DescribeClusterTracksResult", stack)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn describe_cluster_versions(
&self,
input: DescribeClusterVersionsMessage,
) -> Result<ClusterVersionsMessage, RusotoError<DescribeClusterVersionsError>> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let params = self.new_params("DescribeClusterVersions");
let mut params = params;
DescribeClusterVersionsMessageSerializer::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, DescribeClusterVersionsError::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 = ClusterVersionsMessageDeserializer::deserialize(
"DescribeClusterVersionsResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn describe_clusters(
&self,
input: DescribeClustersMessage,
) -> Result<ClustersMessage, RusotoError<DescribeClustersError>> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let params = self.new_params("DescribeClusters");
let mut params = params;
DescribeClustersMessageSerializer::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, DescribeClustersError::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 = ClustersMessageDeserializer::deserialize("DescribeClustersResult", stack)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn describe_default_cluster_parameters(
&self,
input: DescribeDefaultClusterParametersMessage,
) -> Result<
DescribeDefaultClusterParametersResult,
RusotoError<DescribeDefaultClusterParametersError>,
> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let params = self.new_params("DescribeDefaultClusterParameters");
let mut params = params;
DescribeDefaultClusterParametersMessageSerializer::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,
DescribeDefaultClusterParametersError::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 = DescribeDefaultClusterParametersResultDeserializer::deserialize(
"DescribeDefaultClusterParametersResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn describe_event_categories(
&self,
input: DescribeEventCategoriesMessage,
) -> Result<EventCategoriesMessage, RusotoError<DescribeEventCategoriesError>> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let params = self.new_params("DescribeEventCategories");
let mut params = params;
DescribeEventCategoriesMessageSerializer::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, DescribeEventCategoriesError::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 = EventCategoriesMessageDeserializer::deserialize(
"DescribeEventCategoriesResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn describe_event_subscriptions(
&self,
input: DescribeEventSubscriptionsMessage,
) -> Result<EventSubscriptionsMessage, RusotoError<DescribeEventSubscriptionsError>> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let params = self.new_params("DescribeEventSubscriptions");
let mut params = params;
DescribeEventSubscriptionsMessageSerializer::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, DescribeEventSubscriptionsError::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 = EventSubscriptionsMessageDeserializer::deserialize(
"DescribeEventSubscriptionsResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn describe_events(
&self,
input: DescribeEventsMessage,
) -> Result<EventsMessage, RusotoError<DescribeEventsError>> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let params = self.new_params("DescribeEvents");
let mut params = params;
DescribeEventsMessageSerializer::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, DescribeEventsError::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 = EventsMessageDeserializer::deserialize("DescribeEventsResult", stack)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn describe_hsm_client_certificates(
&self,
input: DescribeHsmClientCertificatesMessage,
) -> Result<HsmClientCertificateMessage, RusotoError<DescribeHsmClientCertificatesError>> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let params = self.new_params("DescribeHsmClientCertificates");
let mut params = params;
DescribeHsmClientCertificatesMessageSerializer::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, DescribeHsmClientCertificatesError::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 = HsmClientCertificateMessageDeserializer::deserialize(
"DescribeHsmClientCertificatesResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn describe_hsm_configurations(
&self,
input: DescribeHsmConfigurationsMessage,
) -> Result<HsmConfigurationMessage, RusotoError<DescribeHsmConfigurationsError>> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let params = self.new_params("DescribeHsmConfigurations");
let mut params = params;
DescribeHsmConfigurationsMessageSerializer::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, DescribeHsmConfigurationsError::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 = HsmConfigurationMessageDeserializer::deserialize(
"DescribeHsmConfigurationsResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn describe_logging_status(
&self,
input: DescribeLoggingStatusMessage,
) -> Result<LoggingStatus, RusotoError<DescribeLoggingStatusError>> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let params = self.new_params("DescribeLoggingStatus");
let mut params = params;
DescribeLoggingStatusMessageSerializer::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, DescribeLoggingStatusError::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 =
LoggingStatusDeserializer::deserialize("DescribeLoggingStatusResult", stack)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn describe_node_configuration_options(
&self,
input: DescribeNodeConfigurationOptionsMessage,
) -> Result<NodeConfigurationOptionsMessage, RusotoError<DescribeNodeConfigurationOptionsError>>
{
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let params = self.new_params("DescribeNodeConfigurationOptions");
let mut params = params;
DescribeNodeConfigurationOptionsMessageSerializer::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,
DescribeNodeConfigurationOptionsError::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 = NodeConfigurationOptionsMessageDeserializer::deserialize(
"DescribeNodeConfigurationOptionsResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn describe_orderable_cluster_options(
&self,
input: DescribeOrderableClusterOptionsMessage,
) -> Result<OrderableClusterOptionsMessage, RusotoError<DescribeOrderableClusterOptionsError>>
{
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let params = self.new_params("DescribeOrderableClusterOptions");
let mut params = params;
DescribeOrderableClusterOptionsMessageSerializer::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, DescribeOrderableClusterOptionsError::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 = OrderableClusterOptionsMessageDeserializer::deserialize(
"DescribeOrderableClusterOptionsResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn describe_reserved_node_offerings(
&self,
input: DescribeReservedNodeOfferingsMessage,
) -> Result<ReservedNodeOfferingsMessage, RusotoError<DescribeReservedNodeOfferingsError>> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let params = self.new_params("DescribeReservedNodeOfferings");
let mut params = params;
DescribeReservedNodeOfferingsMessageSerializer::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, DescribeReservedNodeOfferingsError::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 = ReservedNodeOfferingsMessageDeserializer::deserialize(
"DescribeReservedNodeOfferingsResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn describe_reserved_nodes(
&self,
input: DescribeReservedNodesMessage,
) -> Result<ReservedNodesMessage, RusotoError<DescribeReservedNodesError>> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let params = self.new_params("DescribeReservedNodes");
let mut params = params;
DescribeReservedNodesMessageSerializer::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, DescribeReservedNodesError::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 = ReservedNodesMessageDeserializer::deserialize(
"DescribeReservedNodesResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn describe_resize(
&self,
input: DescribeResizeMessage,
) -> Result<ResizeProgressMessage, RusotoError<DescribeResizeError>> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let params = self.new_params("DescribeResize");
let mut params = params;
DescribeResizeMessageSerializer::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, DescribeResizeError::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 =
ResizeProgressMessageDeserializer::deserialize("DescribeResizeResult", stack)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn describe_scheduled_actions(
&self,
input: DescribeScheduledActionsMessage,
) -> Result<ScheduledActionsMessage, RusotoError<DescribeScheduledActionsError>> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let params = self.new_params("DescribeScheduledActions");
let mut params = params;
DescribeScheduledActionsMessageSerializer::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, DescribeScheduledActionsError::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 = ScheduledActionsMessageDeserializer::deserialize(
"DescribeScheduledActionsResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn describe_snapshot_copy_grants(
&self,
input: DescribeSnapshotCopyGrantsMessage,
) -> Result<SnapshotCopyGrantMessage, RusotoError<DescribeSnapshotCopyGrantsError>> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let params = self.new_params("DescribeSnapshotCopyGrants");
let mut params = params;
DescribeSnapshotCopyGrantsMessageSerializer::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, DescribeSnapshotCopyGrantsError::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 = SnapshotCopyGrantMessageDeserializer::deserialize(
"DescribeSnapshotCopyGrantsResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn describe_snapshot_schedules(
&self,
input: DescribeSnapshotSchedulesMessage,
) -> Result<DescribeSnapshotSchedulesOutputMessage, RusotoError<DescribeSnapshotSchedulesError>>
{
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let params = self.new_params("DescribeSnapshotSchedules");
let mut params = params;
DescribeSnapshotSchedulesMessageSerializer::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, DescribeSnapshotSchedulesError::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 = DescribeSnapshotSchedulesOutputMessageDeserializer::deserialize(
"DescribeSnapshotSchedulesResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn describe_storage(
&self,
) -> Result<CustomerStorageMessage, RusotoError<DescribeStorageError>> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let params = self.new_params("DescribeStorage");
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, DescribeStorageError::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 =
CustomerStorageMessageDeserializer::deserialize("DescribeStorageResult", stack)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn describe_table_restore_status(
&self,
input: DescribeTableRestoreStatusMessage,
) -> Result<TableRestoreStatusMessage, RusotoError<DescribeTableRestoreStatusError>> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let params = self.new_params("DescribeTableRestoreStatus");
let mut params = params;
DescribeTableRestoreStatusMessageSerializer::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, DescribeTableRestoreStatusError::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 = TableRestoreStatusMessageDeserializer::deserialize(
"DescribeTableRestoreStatusResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn describe_tags(
&self,
input: DescribeTagsMessage,
) -> Result<TaggedResourceListMessage, RusotoError<DescribeTagsError>> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let params = self.new_params("DescribeTags");
let mut params = params;
DescribeTagsMessageSerializer::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, DescribeTagsError::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 =
TaggedResourceListMessageDeserializer::deserialize("DescribeTagsResult", stack)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn describe_usage_limits(
&self,
input: DescribeUsageLimitsMessage,
) -> Result<UsageLimitList, RusotoError<DescribeUsageLimitsError>> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let params = self.new_params("DescribeUsageLimits");
let mut params = params;
DescribeUsageLimitsMessageSerializer::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, DescribeUsageLimitsError::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 =
UsageLimitListDeserializer::deserialize("DescribeUsageLimitsResult", stack)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn disable_logging(
&self,
input: DisableLoggingMessage,
) -> Result<LoggingStatus, RusotoError<DisableLoggingError>> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let params = self.new_params("DisableLogging");
let mut params = params;
DisableLoggingMessageSerializer::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, DisableLoggingError::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 = LoggingStatusDeserializer::deserialize("DisableLoggingResult", stack)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn disable_snapshot_copy(
&self,
input: DisableSnapshotCopyMessage,
) -> Result<DisableSnapshotCopyResult, RusotoError<DisableSnapshotCopyError>> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let params = self.new_params("DisableSnapshotCopy");
let mut params = params;
DisableSnapshotCopyMessageSerializer::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, DisableSnapshotCopyError::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 = DisableSnapshotCopyResultDeserializer::deserialize(
"DisableSnapshotCopyResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn enable_logging(
&self,
input: EnableLoggingMessage,
) -> Result<LoggingStatus, RusotoError<EnableLoggingError>> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let params = self.new_params("EnableLogging");
let mut params = params;
EnableLoggingMessageSerializer::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, EnableLoggingError::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 = LoggingStatusDeserializer::deserialize("EnableLoggingResult", stack)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn enable_snapshot_copy(
&self,
input: EnableSnapshotCopyMessage,
) -> Result<EnableSnapshotCopyResult, RusotoError<EnableSnapshotCopyError>> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let params = self.new_params("EnableSnapshotCopy");
let mut params = params;
EnableSnapshotCopyMessageSerializer::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, EnableSnapshotCopyError::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 = EnableSnapshotCopyResultDeserializer::deserialize(
"EnableSnapshotCopyResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn get_cluster_credentials(
&self,
input: GetClusterCredentialsMessage,
) -> Result<ClusterCredentials, RusotoError<GetClusterCredentialsError>> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let params = self.new_params("GetClusterCredentials");
let mut params = params;
GetClusterCredentialsMessageSerializer::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, GetClusterCredentialsError::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 =
ClusterCredentialsDeserializer::deserialize("GetClusterCredentialsResult", stack)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn get_reserved_node_exchange_offerings(
&self,
input: GetReservedNodeExchangeOfferingsInputMessage,
) -> Result<
GetReservedNodeExchangeOfferingsOutputMessage,
RusotoError<GetReservedNodeExchangeOfferingsError>,
> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let params = self.new_params("GetReservedNodeExchangeOfferings");
let mut params = params;
GetReservedNodeExchangeOfferingsInputMessageSerializer::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,
GetReservedNodeExchangeOfferingsError::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 = GetReservedNodeExchangeOfferingsOutputMessageDeserializer::deserialize(
"GetReservedNodeExchangeOfferingsResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn modify_cluster(
&self,
input: ModifyClusterMessage,
) -> Result<ModifyClusterResult, RusotoError<ModifyClusterError>> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let params = self.new_params("ModifyCluster");
let mut params = params;
ModifyClusterMessageSerializer::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, ModifyClusterError::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 =
ModifyClusterResultDeserializer::deserialize("ModifyClusterResult", stack)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn modify_cluster_db_revision(
&self,
input: ModifyClusterDbRevisionMessage,
) -> Result<ModifyClusterDbRevisionResult, RusotoError<ModifyClusterDbRevisionError>> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let params = self.new_params("ModifyClusterDbRevision");
let mut params = params;
ModifyClusterDbRevisionMessageSerializer::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, ModifyClusterDbRevisionError::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 = ModifyClusterDbRevisionResultDeserializer::deserialize(
"ModifyClusterDbRevisionResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn modify_cluster_iam_roles(
&self,
input: ModifyClusterIamRolesMessage,
) -> Result<ModifyClusterIamRolesResult, RusotoError<ModifyClusterIamRolesError>> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let params = self.new_params("ModifyClusterIamRoles");
let mut params = params;
ModifyClusterIamRolesMessageSerializer::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, ModifyClusterIamRolesError::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 = ModifyClusterIamRolesResultDeserializer::deserialize(
"ModifyClusterIamRolesResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn modify_cluster_maintenance(
&self,
input: ModifyClusterMaintenanceMessage,
) -> Result<ModifyClusterMaintenanceResult, RusotoError<ModifyClusterMaintenanceError>> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let params = self.new_params("ModifyClusterMaintenance");
let mut params = params;
ModifyClusterMaintenanceMessageSerializer::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, ModifyClusterMaintenanceError::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 = ModifyClusterMaintenanceResultDeserializer::deserialize(
"ModifyClusterMaintenanceResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn modify_cluster_parameter_group(
&self,
input: ModifyClusterParameterGroupMessage,
) -> Result<ClusterParameterGroupNameMessage, RusotoError<ModifyClusterParameterGroupError>>
{
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let params = self.new_params("ModifyClusterParameterGroup");
let mut params = params;
ModifyClusterParameterGroupMessageSerializer::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, ModifyClusterParameterGroupError::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 = ClusterParameterGroupNameMessageDeserializer::deserialize(
"ModifyClusterParameterGroupResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn modify_cluster_snapshot(
&self,
input: ModifyClusterSnapshotMessage,
) -> Result<ModifyClusterSnapshotResult, RusotoError<ModifyClusterSnapshotError>> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let params = self.new_params("ModifyClusterSnapshot");
let mut params = params;
ModifyClusterSnapshotMessageSerializer::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, ModifyClusterSnapshotError::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 = ModifyClusterSnapshotResultDeserializer::deserialize(
"ModifyClusterSnapshotResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn modify_cluster_snapshot_schedule(
&self,
input: ModifyClusterSnapshotScheduleMessage,
) -> Result<(), RusotoError<ModifyClusterSnapshotScheduleError>> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let params = self.new_params("ModifyClusterSnapshotSchedule");
let mut params = params;
ModifyClusterSnapshotScheduleMessageSerializer::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, ModifyClusterSnapshotScheduleError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
async fn modify_cluster_subnet_group(
&self,
input: ModifyClusterSubnetGroupMessage,
) -> Result<ModifyClusterSubnetGroupResult, RusotoError<ModifyClusterSubnetGroupError>> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let params = self.new_params("ModifyClusterSubnetGroup");
let mut params = params;
ModifyClusterSubnetGroupMessageSerializer::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, ModifyClusterSubnetGroupError::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 = ModifyClusterSubnetGroupResultDeserializer::deserialize(
"ModifyClusterSubnetGroupResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn modify_event_subscription(
&self,
input: ModifyEventSubscriptionMessage,
) -> Result<ModifyEventSubscriptionResult, RusotoError<ModifyEventSubscriptionError>> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let params = self.new_params("ModifyEventSubscription");
let mut params = params;
ModifyEventSubscriptionMessageSerializer::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, ModifyEventSubscriptionError::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 = ModifyEventSubscriptionResultDeserializer::deserialize(
"ModifyEventSubscriptionResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn modify_scheduled_action(
&self,
input: ModifyScheduledActionMessage,
) -> Result<ScheduledAction, RusotoError<ModifyScheduledActionError>> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let params = self.new_params("ModifyScheduledAction");
let mut params = params;
ModifyScheduledActionMessageSerializer::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, ModifyScheduledActionError::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 =
ScheduledActionDeserializer::deserialize("ModifyScheduledActionResult", stack)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn modify_snapshot_copy_retention_period(
&self,
input: ModifySnapshotCopyRetentionPeriodMessage,
) -> Result<
ModifySnapshotCopyRetentionPeriodResult,
RusotoError<ModifySnapshotCopyRetentionPeriodError>,
> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let params = self.new_params("ModifySnapshotCopyRetentionPeriod");
let mut params = params;
ModifySnapshotCopyRetentionPeriodMessageSerializer::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,
ModifySnapshotCopyRetentionPeriodError::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 = ModifySnapshotCopyRetentionPeriodResultDeserializer::deserialize(
"ModifySnapshotCopyRetentionPeriodResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn modify_snapshot_schedule(
&self,
input: ModifySnapshotScheduleMessage,
) -> Result<SnapshotSchedule, RusotoError<ModifySnapshotScheduleError>> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let params = self.new_params("ModifySnapshotSchedule");
let mut params = params;
ModifySnapshotScheduleMessageSerializer::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, ModifySnapshotScheduleError::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 =
SnapshotScheduleDeserializer::deserialize("ModifySnapshotScheduleResult", stack)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn modify_usage_limit(
&self,
input: ModifyUsageLimitMessage,
) -> Result<UsageLimit, RusotoError<ModifyUsageLimitError>> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let params = self.new_params("ModifyUsageLimit");
let mut params = params;
ModifyUsageLimitMessageSerializer::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, ModifyUsageLimitError::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 = UsageLimitDeserializer::deserialize("ModifyUsageLimitResult", stack)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn pause_cluster(
&self,
input: PauseClusterMessage,
) -> Result<PauseClusterResult, RusotoError<PauseClusterError>> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let params = self.new_params("PauseCluster");
let mut params = params;
PauseClusterMessageSerializer::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, PauseClusterError::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 = PauseClusterResultDeserializer::deserialize("PauseClusterResult", stack)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn purchase_reserved_node_offering(
&self,
input: PurchaseReservedNodeOfferingMessage,
) -> Result<PurchaseReservedNodeOfferingResult, RusotoError<PurchaseReservedNodeOfferingError>>
{
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let params = self.new_params("PurchaseReservedNodeOffering");
let mut params = params;
PurchaseReservedNodeOfferingMessageSerializer::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, PurchaseReservedNodeOfferingError::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 = PurchaseReservedNodeOfferingResultDeserializer::deserialize(
"PurchaseReservedNodeOfferingResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn reboot_cluster(
&self,
input: RebootClusterMessage,
) -> Result<RebootClusterResult, RusotoError<RebootClusterError>> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let params = self.new_params("RebootCluster");
let mut params = params;
RebootClusterMessageSerializer::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, RebootClusterError::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 =
RebootClusterResultDeserializer::deserialize("RebootClusterResult", stack)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn reset_cluster_parameter_group(
&self,
input: ResetClusterParameterGroupMessage,
) -> Result<ClusterParameterGroupNameMessage, RusotoError<ResetClusterParameterGroupError>>
{
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let params = self.new_params("ResetClusterParameterGroup");
let mut params = params;
ResetClusterParameterGroupMessageSerializer::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, ResetClusterParameterGroupError::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 = ClusterParameterGroupNameMessageDeserializer::deserialize(
"ResetClusterParameterGroupResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn resize_cluster(
&self,
input: ResizeClusterMessage,
) -> Result<ResizeClusterResult, RusotoError<ResizeClusterError>> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let params = self.new_params("ResizeCluster");
let mut params = params;
ResizeClusterMessageSerializer::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, ResizeClusterError::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 =
ResizeClusterResultDeserializer::deserialize("ResizeClusterResult", stack)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn restore_from_cluster_snapshot(
&self,
input: RestoreFromClusterSnapshotMessage,
) -> Result<RestoreFromClusterSnapshotResult, RusotoError<RestoreFromClusterSnapshotError>>
{
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let params = self.new_params("RestoreFromClusterSnapshot");
let mut params = params;
RestoreFromClusterSnapshotMessageSerializer::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, RestoreFromClusterSnapshotError::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 = RestoreFromClusterSnapshotResultDeserializer::deserialize(
"RestoreFromClusterSnapshotResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn restore_table_from_cluster_snapshot(
&self,
input: RestoreTableFromClusterSnapshotMessage,
) -> Result<
RestoreTableFromClusterSnapshotResult,
RusotoError<RestoreTableFromClusterSnapshotError>,
> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let params = self.new_params("RestoreTableFromClusterSnapshot");
let mut params = params;
RestoreTableFromClusterSnapshotMessageSerializer::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, RestoreTableFromClusterSnapshotError::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 = RestoreTableFromClusterSnapshotResultDeserializer::deserialize(
"RestoreTableFromClusterSnapshotResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn resume_cluster(
&self,
input: ResumeClusterMessage,
) -> Result<ResumeClusterResult, RusotoError<ResumeClusterError>> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let params = self.new_params("ResumeCluster");
let mut params = params;
ResumeClusterMessageSerializer::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, ResumeClusterError::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 =
ResumeClusterResultDeserializer::deserialize("ResumeClusterResult", stack)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn revoke_cluster_security_group_ingress(
&self,
input: RevokeClusterSecurityGroupIngressMessage,
) -> Result<
RevokeClusterSecurityGroupIngressResult,
RusotoError<RevokeClusterSecurityGroupIngressError>,
> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let params = self.new_params("RevokeClusterSecurityGroupIngress");
let mut params = params;
RevokeClusterSecurityGroupIngressMessageSerializer::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,
RevokeClusterSecurityGroupIngressError::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 = RevokeClusterSecurityGroupIngressResultDeserializer::deserialize(
"RevokeClusterSecurityGroupIngressResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn revoke_snapshot_access(
&self,
input: RevokeSnapshotAccessMessage,
) -> Result<RevokeSnapshotAccessResult, RusotoError<RevokeSnapshotAccessError>> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let params = self.new_params("RevokeSnapshotAccess");
let mut params = params;
RevokeSnapshotAccessMessageSerializer::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, RevokeSnapshotAccessError::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 = RevokeSnapshotAccessResultDeserializer::deserialize(
"RevokeSnapshotAccessResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn rotate_encryption_key(
&self,
input: RotateEncryptionKeyMessage,
) -> Result<RotateEncryptionKeyResult, RusotoError<RotateEncryptionKeyError>> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let params = self.new_params("RotateEncryptionKey");
let mut params = params;
RotateEncryptionKeyMessageSerializer::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, RotateEncryptionKeyError::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 = RotateEncryptionKeyResultDeserializer::deserialize(
"RotateEncryptionKeyResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
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_valid_redshift_authorize_cluster_security_group_ingress() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"redshift-authorize-cluster-security-group-ingress.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client =
RedshiftClient::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = AuthorizeClusterSecurityGroupIngressMessage::default();
let result = client
.authorize_cluster_security_group_ingress(request)
.await;
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[tokio::test]
async fn test_parse_valid_redshift_copy_cluster_snapshot() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"redshift-copy-cluster-snapshot.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client =
RedshiftClient::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = CopyClusterSnapshotMessage::default();
let result = client.copy_cluster_snapshot(request).await;
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[tokio::test]
async fn test_parse_valid_redshift_create_cluster_parameter_group() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"redshift-create-cluster-parameter-group.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client =
RedshiftClient::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = CreateClusterParameterGroupMessage::default();
let result = client.create_cluster_parameter_group(request).await;
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[tokio::test]
async fn test_parse_valid_redshift_create_cluster_security_group() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"redshift-create-cluster-security-group.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client =
RedshiftClient::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = CreateClusterSecurityGroupMessage::default();
let result = client.create_cluster_security_group(request).await;
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[tokio::test]
async fn test_parse_valid_redshift_create_cluster_snapshot() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"redshift-create-cluster-snapshot.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client =
RedshiftClient::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = CreateClusterSnapshotMessage::default();
let result = client.create_cluster_snapshot(request).await;
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[tokio::test]
async fn test_parse_valid_redshift_create_cluster_subnet_group() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"redshift-create-cluster-subnet-group.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client =
RedshiftClient::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = CreateClusterSubnetGroupMessage::default();
let result = client.create_cluster_subnet_group(request).await;
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[tokio::test]
async fn test_parse_valid_redshift_create_cluster() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"redshift-create-cluster.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client =
RedshiftClient::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = CreateClusterMessage::default();
let result = client.create_cluster(request).await;
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[tokio::test]
async fn test_parse_valid_redshift_delete_cluster_parameter_group() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"redshift-delete-cluster-parameter-group.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client =
RedshiftClient::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = DeleteClusterParameterGroupMessage::default();
let result = client.delete_cluster_parameter_group(request).await;
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[tokio::test]
async fn test_parse_valid_redshift_delete_cluster_snapshot() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"redshift-delete-cluster-snapshot.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client =
RedshiftClient::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = DeleteClusterSnapshotMessage::default();
let result = client.delete_cluster_snapshot(request).await;
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[tokio::test]
async fn test_parse_valid_redshift_delete_cluster() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"redshift-delete-cluster.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client =
RedshiftClient::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = DeleteClusterMessage::default();
let result = client.delete_cluster(request).await;
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[tokio::test]
async fn test_parse_valid_redshift_describe_cluster_parameter_groups() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"redshift-describe-cluster-parameter-groups.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client =
RedshiftClient::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = DescribeClusterParameterGroupsMessage::default();
let result = client.describe_cluster_parameter_groups(request).await;
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[tokio::test]
async fn test_parse_valid_redshift_describe_cluster_parameters() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"redshift-describe-cluster-parameters.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client =
RedshiftClient::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = DescribeClusterParametersMessage::default();
let result = client.describe_cluster_parameters(request).await;
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[tokio::test]
async fn test_parse_valid_redshift_describe_cluster_security_groups() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"redshift-describe-cluster-security-groups.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client =
RedshiftClient::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = DescribeClusterSecurityGroupsMessage::default();
let result = client.describe_cluster_security_groups(request).await;
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[tokio::test]
async fn test_parse_valid_redshift_describe_cluster_snapshots() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"redshift-describe-cluster-snapshots.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client =
RedshiftClient::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = DescribeClusterSnapshotsMessage::default();
let result = client.describe_cluster_snapshots(request).await;
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[tokio::test]
async fn test_parse_valid_redshift_describe_cluster_subnet_groups() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"redshift-describe-cluster-subnet-groups.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client =
RedshiftClient::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = DescribeClusterSubnetGroupsMessage::default();
let result = client.describe_cluster_subnet_groups(request).await;
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[tokio::test]
async fn test_parse_valid_redshift_describe_cluster_versions() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"redshift-describe-cluster-versions.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client =
RedshiftClient::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = DescribeClusterVersionsMessage::default();
let result = client.describe_cluster_versions(request).await;
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[tokio::test]
async fn test_parse_valid_redshift_describe_clusters() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"redshift-describe-clusters.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client =
RedshiftClient::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = DescribeClustersMessage::default();
let result = client.describe_clusters(request).await;
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[tokio::test]
async fn test_parse_valid_redshift_describe_events() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"redshift-describe-events.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client =
RedshiftClient::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = DescribeEventsMessage::default();
let result = client.describe_events(request).await;
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[tokio::test]
async fn test_parse_valid_redshift_describe_orderable_cluster_options() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"redshift-describe-orderable-cluster-options.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client =
RedshiftClient::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = DescribeOrderableClusterOptionsMessage::default();
let result = client.describe_orderable_cluster_options(request).await;
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[tokio::test]
async fn test_parse_valid_redshift_describe_reserved_node_offerings() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"redshift-describe-reserved-node-offerings.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client =
RedshiftClient::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = DescribeReservedNodeOfferingsMessage::default();
let result = client.describe_reserved_node_offerings(request).await;
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[tokio::test]
async fn test_parse_valid_redshift_describe_reserved_nodes() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"redshift-describe-reserved-nodes.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client =
RedshiftClient::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = DescribeReservedNodesMessage::default();
let result = client.describe_reserved_nodes(request).await;
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[tokio::test]
async fn test_parse_valid_redshift_describe_resize() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"redshift-describe-resize.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client =
RedshiftClient::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = DescribeResizeMessage::default();
let result = client.describe_resize(request).await;
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[tokio::test]
async fn test_parse_valid_redshift_modify_cluster_parameter_group() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"redshift-modify-cluster-parameter-group.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client =
RedshiftClient::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = ModifyClusterParameterGroupMessage::default();
let result = client.modify_cluster_parameter_group(request).await;
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[tokio::test]
async fn test_parse_valid_redshift_purchase_reserved_node_offering() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"redshift-purchase-reserved-node-offering.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client =
RedshiftClient::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = PurchaseReservedNodeOfferingMessage::default();
let result = client.purchase_reserved_node_offering(request).await;
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[tokio::test]
async fn test_parse_valid_redshift_reboot_cluster() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"redshift-reboot-cluster.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client =
RedshiftClient::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = RebootClusterMessage::default();
let result = client.reboot_cluster(request).await;
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[tokio::test]
async fn test_parse_valid_redshift_reset_cluster_parameter_group() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"redshift-reset-cluster-parameter-group.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client =
RedshiftClient::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = ResetClusterParameterGroupMessage::default();
let result = client.reset_cluster_parameter_group(request).await;
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[tokio::test]
async fn test_parse_valid_redshift_restore_from_cluster_snapshot() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"redshift-restore-from-cluster-snapshot.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client =
RedshiftClient::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = RestoreFromClusterSnapshotMessage::default();
let result = client.restore_from_cluster_snapshot(request).await;
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[tokio::test]
async fn test_parse_valid_redshift_revoke_cluster_security_group_ingress() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"redshift-revoke-cluster-security-group-ingress.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client =
RedshiftClient::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = RevokeClusterSecurityGroupIngressMessage::default();
let result = client.revoke_cluster_security_group_ingress(request).await;
assert!(result.is_ok(), "parse error: {:?}", result);
}
}