use std::error::Error;
use std::fmt;
use std::io;
#[allow(warnings)]
use futures::future;
use futures::Future;
use rusoto_core::region;
use rusoto_core::request::{BufferedHttpResponse, DispatchSignedRequest};
use rusoto_core::{Client, RusotoFuture};
use rusoto_core::credential::{CredentialsError, ProvideAwsCredentials};
use rusoto_core::request::HttpDispatchError;
use rusoto_core::param::{Params, ServiceParams};
use rusoto_core::signature::SignedRequest;
use rusoto_core::xmlerror::*;
use rusoto_core::xmlutil::{
characters, end_element, find_start_element, peek_at_name, skip_tree, start_element,
};
use rusoto_core::xmlutil::{Next, Peek, XmlParseError, XmlResponse};
use serde_urlencoded;
use std::str::FromStr;
use xml::reader::ParserConfig;
use xml::reader::XmlEvent;
use xml::EventReader;
enum DeserializerNext {
Close,
Skip,
Element(String),
}
#[derive(Default, Debug, Clone, PartialEq)]
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(Default, Debug, Clone, PartialEq)]
pub struct AcceptReservedNodeExchangeOutputMessage {
pub exchanged_reserved_node: Option<ReservedNode>,
}
struct AcceptReservedNodeExchangeOutputMessageDeserializer;
impl AcceptReservedNodeExchangeOutputMessageDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<AcceptReservedNodeExchangeOutputMessage, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = AcceptReservedNodeExchangeOutputMessage::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"ExchangedReservedNode" => {
obj.exchanged_reserved_node = Some(try!(
ReservedNodeDeserializer::deserialize("ExchangedReservedNode", stack)
));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct AccountWithRestoreAccess {
pub account_alias: Option<String>,
pub account_id: Option<String>,
}
struct AccountWithRestoreAccessDeserializer;
impl AccountWithRestoreAccessDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<AccountWithRestoreAccess, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = AccountWithRestoreAccess::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"AccountAlias" => {
obj.account_alias =
Some(try!(StringDeserializer::deserialize("AccountAlias", stack)));
}
"AccountId" => {
obj.account_id =
Some(try!(StringDeserializer::deserialize("AccountId", stack)));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
struct AccountsWithRestoreAccessListDeserializer;
impl AccountsWithRestoreAccessListDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<AccountWithRestoreAccess>, XmlParseError> {
let mut obj = vec![];
try!(start_element(tag_name, stack));
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "AccountWithRestoreAccess" {
obj.push(try!(AccountWithRestoreAccessDeserializer::deserialize(
"AccountWithRestoreAccess",
stack
)));
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
try!(end_element(tag_name, stack));
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct 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(Default, Debug, Clone, PartialEq)]
pub struct AuthorizeClusterSecurityGroupIngressResult {
pub cluster_security_group: Option<ClusterSecurityGroup>,
}
struct AuthorizeClusterSecurityGroupIngressResultDeserializer;
impl AuthorizeClusterSecurityGroupIngressResultDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<AuthorizeClusterSecurityGroupIngressResult, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = AuthorizeClusterSecurityGroupIngressResult::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"ClusterSecurityGroup" => {
obj.cluster_security_group =
Some(try!(ClusterSecurityGroupDeserializer::deserialize(
"ClusterSecurityGroup",
stack
)));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct 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(Default, Debug, Clone, PartialEq)]
pub struct AuthorizeSnapshotAccessResult {
pub snapshot: Option<Snapshot>,
}
struct AuthorizeSnapshotAccessResultDeserializer;
impl AuthorizeSnapshotAccessResultDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<AuthorizeSnapshotAccessResult, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = AuthorizeSnapshotAccessResult::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"Snapshot" => {
obj.snapshot =
Some(try!(SnapshotDeserializer::deserialize("Snapshot", stack)));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct AvailabilityZone {
pub name: Option<String>,
pub supported_platforms: Option<Vec<SupportedPlatform>>,
}
struct AvailabilityZoneDeserializer;
impl AvailabilityZoneDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<AvailabilityZone, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = AvailabilityZone::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"Name" => {
obj.name = Some(try!(StringDeserializer::deserialize("Name", stack)));
}
"SupportedPlatforms" => {
obj.supported_platforms = match obj.supported_platforms {
Some(ref mut existing) => {
existing.extend(try!(
SupportedPlatformsListDeserializer::deserialize(
"SupportedPlatforms",
stack
)
));
Some(existing.to_vec())
}
None => Some(try!(SupportedPlatformsListDeserializer::deserialize(
"SupportedPlatforms",
stack
))),
};
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
struct AvailabilityZoneListDeserializer;
impl AvailabilityZoneListDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<AvailabilityZone>, XmlParseError> {
let mut obj = vec![];
try!(start_element(tag_name, stack));
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "AvailabilityZone" {
obj.push(try!(AvailabilityZoneDeserializer::deserialize(
"AvailabilityZone",
stack
)));
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
try!(end_element(tag_name, stack));
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
struct BooleanDeserializer;
impl BooleanDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<bool, XmlParseError> {
try!(start_element(tag_name, stack));
let obj = bool::from_str(try!(characters(stack)).as_ref()).unwrap();
try!(end_element(tag_name, stack));
Ok(obj)
}
}
struct BooleanOptionalDeserializer;
impl BooleanOptionalDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<bool, XmlParseError> {
try!(start_element(tag_name, stack));
let obj = bool::from_str(try!(characters(stack)).as_ref()).unwrap();
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct Cluster {
pub allow_version_upgrade: Option<bool>,
pub automated_snapshot_retention_period: Option<i64>,
pub availability_zone: 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 elastic_ip_status: Option<ElasticIpStatus>,
pub encrypted: Option<bool>,
pub endpoint: Option<Endpoint>,
pub enhanced_vpc_routing: Option<bool>,
pub hsm_status: Option<HsmStatus>,
pub iam_roles: Option<Vec<ClusterIamRole>>,
pub kms_key_id: Option<String>,
pub maintenance_track_name: Option<String>,
pub master_username: Option<String>,
pub modify_status: 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 restore_status: Option<RestoreStatus>,
pub tags: Option<Vec<Tag>>,
pub vpc_id: Option<String>,
pub vpc_security_groups: Option<Vec<VpcSecurityGroupMembership>>,
}
struct ClusterDeserializer;
impl ClusterDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Cluster, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = Cluster::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"AllowVersionUpgrade" => {
obj.allow_version_upgrade = Some(try!(BooleanDeserializer::deserialize(
"AllowVersionUpgrade",
stack
)));
}
"AutomatedSnapshotRetentionPeriod" => {
obj.automated_snapshot_retention_period =
Some(try!(IntegerDeserializer::deserialize(
"AutomatedSnapshotRetentionPeriod",
stack
)));
}
"AvailabilityZone" => {
obj.availability_zone = Some(try!(StringDeserializer::deserialize(
"AvailabilityZone",
stack
)));
}
"ClusterCreateTime" => {
obj.cluster_create_time = Some(try!(TStampDeserializer::deserialize(
"ClusterCreateTime",
stack
)));
}
"ClusterIdentifier" => {
obj.cluster_identifier = Some(try!(StringDeserializer::deserialize(
"ClusterIdentifier",
stack
)));
}
"ClusterNodes" => {
obj.cluster_nodes = match obj.cluster_nodes {
Some(ref mut existing) => {
existing.extend(try!(ClusterNodesListDeserializer::deserialize(
"ClusterNodes",
stack
)));
Some(existing.to_vec())
}
None => Some(try!(ClusterNodesListDeserializer::deserialize(
"ClusterNodes",
stack
))),
};
}
"ClusterParameterGroups" => {
obj.cluster_parameter_groups = match obj.cluster_parameter_groups {
Some(ref mut existing) => {
existing.extend(try!(
ClusterParameterGroupStatusListDeserializer::deserialize(
"ClusterParameterGroups",
stack
)
));
Some(existing.to_vec())
}
None => Some(try!(
ClusterParameterGroupStatusListDeserializer::deserialize(
"ClusterParameterGroups",
stack
)
)),
};
}
"ClusterPublicKey" => {
obj.cluster_public_key = Some(try!(StringDeserializer::deserialize(
"ClusterPublicKey",
stack
)));
}
"ClusterRevisionNumber" => {
obj.cluster_revision_number = Some(try!(StringDeserializer::deserialize(
"ClusterRevisionNumber",
stack
)));
}
"ClusterSecurityGroups" => {
obj.cluster_security_groups = match obj.cluster_security_groups {
Some(ref mut existing) => {
existing.extend(try!(
ClusterSecurityGroupMembershipListDeserializer::deserialize(
"ClusterSecurityGroups",
stack
)
));
Some(existing.to_vec())
}
None => Some(try!(
ClusterSecurityGroupMembershipListDeserializer::deserialize(
"ClusterSecurityGroups",
stack
)
)),
};
}
"ClusterSnapshotCopyStatus" => {
obj.cluster_snapshot_copy_status =
Some(try!(ClusterSnapshotCopyStatusDeserializer::deserialize(
"ClusterSnapshotCopyStatus",
stack
)));
}
"ClusterStatus" => {
obj.cluster_status = Some(try!(StringDeserializer::deserialize(
"ClusterStatus",
stack
)));
}
"ClusterSubnetGroupName" => {
obj.cluster_subnet_group_name = Some(try!(
StringDeserializer::deserialize("ClusterSubnetGroupName", stack)
));
}
"ClusterVersion" => {
obj.cluster_version = Some(try!(StringDeserializer::deserialize(
"ClusterVersion",
stack
)));
}
"DBName" => {
obj.db_name = Some(try!(StringDeserializer::deserialize("DBName", stack)));
}
"ElasticIpStatus" => {
obj.elastic_ip_status = Some(try!(
ElasticIpStatusDeserializer::deserialize("ElasticIpStatus", stack)
));
}
"Encrypted" => {
obj.encrypted =
Some(try!(BooleanDeserializer::deserialize("Encrypted", stack)));
}
"Endpoint" => {
obj.endpoint =
Some(try!(EndpointDeserializer::deserialize("Endpoint", stack)));
}
"EnhancedVpcRouting" => {
obj.enhanced_vpc_routing = Some(try!(BooleanDeserializer::deserialize(
"EnhancedVpcRouting",
stack
)));
}
"HsmStatus" => {
obj.hsm_status =
Some(try!(HsmStatusDeserializer::deserialize("HsmStatus", stack)));
}
"IamRoles" => {
obj.iam_roles = match obj.iam_roles {
Some(ref mut existing) => {
existing.extend(try!(ClusterIamRoleListDeserializer::deserialize(
"IamRoles", stack
)));
Some(existing.to_vec())
}
None => Some(try!(ClusterIamRoleListDeserializer::deserialize(
"IamRoles", stack
))),
};
}
"KmsKeyId" => {
obj.kms_key_id =
Some(try!(StringDeserializer::deserialize("KmsKeyId", stack)));
}
"MaintenanceTrackName" => {
obj.maintenance_track_name = Some(try!(StringDeserializer::deserialize(
"MaintenanceTrackName",
stack
)));
}
"MasterUsername" => {
obj.master_username = Some(try!(StringDeserializer::deserialize(
"MasterUsername",
stack
)));
}
"ModifyStatus" => {
obj.modify_status =
Some(try!(StringDeserializer::deserialize("ModifyStatus", stack)));
}
"NodeType" => {
obj.node_type =
Some(try!(StringDeserializer::deserialize("NodeType", stack)));
}
"NumberOfNodes" => {
obj.number_of_nodes = Some(try!(IntegerDeserializer::deserialize(
"NumberOfNodes",
stack
)));
}
"PendingActions" => {
obj.pending_actions = match obj.pending_actions {
Some(ref mut existing) => {
existing.extend(try!(PendingActionsListDeserializer::deserialize(
"PendingActions",
stack
)));
Some(existing.to_vec())
}
None => Some(try!(PendingActionsListDeserializer::deserialize(
"PendingActions",
stack
))),
};
}
"PendingModifiedValues" => {
obj.pending_modified_values =
Some(try!(PendingModifiedValuesDeserializer::deserialize(
"PendingModifiedValues",
stack
)));
}
"PreferredMaintenanceWindow" => {
obj.preferred_maintenance_window = Some(try!(
StringDeserializer::deserialize("PreferredMaintenanceWindow", stack)
));
}
"PubliclyAccessible" => {
obj.publicly_accessible = Some(try!(BooleanDeserializer::deserialize(
"PubliclyAccessible",
stack
)));
}
"RestoreStatus" => {
obj.restore_status = Some(try!(RestoreStatusDeserializer::deserialize(
"RestoreStatus",
stack
)));
}
"Tags" => {
obj.tags = match obj.tags {
Some(ref mut existing) => {
existing
.extend(try!(TagListDeserializer::deserialize("Tags", stack)));
Some(existing.to_vec())
}
None => Some(try!(TagListDeserializer::deserialize("Tags", stack))),
};
}
"VpcId" => {
obj.vpc_id = Some(try!(StringDeserializer::deserialize("VpcId", stack)));
}
"VpcSecurityGroups" => {
obj.vpc_security_groups = match obj.vpc_security_groups {
Some(ref mut existing) => {
existing.extend(try!(
VpcSecurityGroupMembershipListDeserializer::deserialize(
"VpcSecurityGroups",
stack
)
));
Some(existing.to_vec())
}
None => Some(try!(
VpcSecurityGroupMembershipListDeserializer::deserialize(
"VpcSecurityGroups",
stack
)
)),
};
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ClusterCredentials {
pub db_password: Option<String>,
pub db_user: Option<String>,
pub expiration: Option<String>,
}
struct ClusterCredentialsDeserializer;
impl ClusterCredentialsDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ClusterCredentials, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = ClusterCredentials::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"DbPassword" => {
obj.db_password = Some(try!(SensitiveStringDeserializer::deserialize(
"DbPassword",
stack
)));
}
"DbUser" => {
obj.db_user = Some(try!(StringDeserializer::deserialize("DbUser", stack)));
}
"Expiration" => {
obj.expiration =
Some(try!(TStampDeserializer::deserialize("Expiration", stack)));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct 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>>,
}
struct ClusterDbRevisionDeserializer;
impl ClusterDbRevisionDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ClusterDbRevision, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = ClusterDbRevision::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"ClusterIdentifier" => {
obj.cluster_identifier = Some(try!(StringDeserializer::deserialize(
"ClusterIdentifier",
stack
)));
}
"CurrentDatabaseRevision" => {
obj.current_database_revision = Some(try!(
StringDeserializer::deserialize("CurrentDatabaseRevision", stack)
));
}
"DatabaseRevisionReleaseDate" => {
obj.database_revision_release_date = Some(try!(
TStampDeserializer::deserialize("DatabaseRevisionReleaseDate", stack)
));
}
"RevisionTargets" => {
obj.revision_targets = match obj.revision_targets {
Some(ref mut existing) => {
existing.extend(try!(
RevisionTargetsListDeserializer::deserialize(
"RevisionTargets",
stack
)
));
Some(existing.to_vec())
}
None => Some(try!(RevisionTargetsListDeserializer::deserialize(
"RevisionTargets",
stack
))),
};
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
struct ClusterDbRevisionsListDeserializer;
impl ClusterDbRevisionsListDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<ClusterDbRevision>, XmlParseError> {
let mut obj = vec![];
try!(start_element(tag_name, stack));
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "ClusterDbRevision" {
obj.push(try!(ClusterDbRevisionDeserializer::deserialize(
"ClusterDbRevision",
stack
)));
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
try!(end_element(tag_name, stack));
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ClusterDbRevisionsMessage {
pub cluster_db_revisions: Option<Vec<ClusterDbRevision>>,
pub marker: Option<String>,
}
struct ClusterDbRevisionsMessageDeserializer;
impl ClusterDbRevisionsMessageDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ClusterDbRevisionsMessage, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = ClusterDbRevisionsMessage::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"ClusterDbRevisions" => {
obj.cluster_db_revisions = match obj.cluster_db_revisions {
Some(ref mut existing) => {
existing.extend(try!(
ClusterDbRevisionsListDeserializer::deserialize(
"ClusterDbRevisions",
stack
)
));
Some(existing.to_vec())
}
None => Some(try!(ClusterDbRevisionsListDeserializer::deserialize(
"ClusterDbRevisions",
stack
))),
};
}
"Marker" => {
obj.marker = Some(try!(StringDeserializer::deserialize("Marker", stack)));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ClusterIamRole {
pub apply_status: Option<String>,
pub iam_role_arn: Option<String>,
}
struct ClusterIamRoleDeserializer;
impl ClusterIamRoleDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ClusterIamRole, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = ClusterIamRole::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"ApplyStatus" => {
obj.apply_status =
Some(try!(StringDeserializer::deserialize("ApplyStatus", stack)));
}
"IamRoleArn" => {
obj.iam_role_arn =
Some(try!(StringDeserializer::deserialize("IamRoleArn", stack)));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
struct ClusterIamRoleListDeserializer;
impl ClusterIamRoleListDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<ClusterIamRole>, XmlParseError> {
let mut obj = vec![];
try!(start_element(tag_name, stack));
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "ClusterIamRole" {
obj.push(try!(ClusterIamRoleDeserializer::deserialize(
"ClusterIamRole",
stack
)));
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
try!(end_element(tag_name, stack));
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
struct ClusterListDeserializer;
impl ClusterListDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<Cluster>, XmlParseError> {
let mut obj = vec![];
try!(start_element(tag_name, stack));
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "Cluster" {
obj.push(try!(ClusterDeserializer::deserialize("Cluster", stack)));
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
try!(end_element(tag_name, stack));
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ClusterNode {
pub node_role: Option<String>,
pub private_ip_address: Option<String>,
pub public_ip_address: Option<String>,
}
struct ClusterNodeDeserializer;
impl ClusterNodeDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ClusterNode, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = ClusterNode::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"NodeRole" => {
obj.node_role =
Some(try!(StringDeserializer::deserialize("NodeRole", stack)));
}
"PrivateIPAddress" => {
obj.private_ip_address = Some(try!(StringDeserializer::deserialize(
"PrivateIPAddress",
stack
)));
}
"PublicIPAddress" => {
obj.public_ip_address = Some(try!(StringDeserializer::deserialize(
"PublicIPAddress",
stack
)));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
struct ClusterNodesListDeserializer;
impl ClusterNodesListDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<ClusterNode>, XmlParseError> {
let mut obj = vec![];
try!(start_element(tag_name, stack));
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "member" {
obj.push(try!(ClusterNodeDeserializer::deserialize("member", stack)));
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
try!(end_element(tag_name, stack));
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ClusterParameterGroup {
pub description: Option<String>,
pub parameter_group_family: Option<String>,
pub parameter_group_name: Option<String>,
pub tags: Option<Vec<Tag>>,
}
struct ClusterParameterGroupDeserializer;
impl ClusterParameterGroupDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ClusterParameterGroup, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = ClusterParameterGroup::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"Description" => {
obj.description =
Some(try!(StringDeserializer::deserialize("Description", stack)));
}
"ParameterGroupFamily" => {
obj.parameter_group_family = Some(try!(StringDeserializer::deserialize(
"ParameterGroupFamily",
stack
)));
}
"ParameterGroupName" => {
obj.parameter_group_name = Some(try!(StringDeserializer::deserialize(
"ParameterGroupName",
stack
)));
}
"Tags" => {
obj.tags = match obj.tags {
Some(ref mut existing) => {
existing
.extend(try!(TagListDeserializer::deserialize("Tags", stack)));
Some(existing.to_vec())
}
None => Some(try!(TagListDeserializer::deserialize("Tags", stack))),
};
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ClusterParameterGroupDetails {
pub marker: Option<String>,
pub parameters: Option<Vec<Parameter>>,
}
struct ClusterParameterGroupDetailsDeserializer;
impl ClusterParameterGroupDetailsDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ClusterParameterGroupDetails, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = ClusterParameterGroupDetails::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"Marker" => {
obj.marker = Some(try!(StringDeserializer::deserialize("Marker", stack)));
}
"Parameters" => {
obj.parameters = match obj.parameters {
Some(ref mut existing) => {
existing.extend(try!(ParametersListDeserializer::deserialize(
"Parameters",
stack
)));
Some(existing.to_vec())
}
None => Some(try!(ParametersListDeserializer::deserialize(
"Parameters",
stack
))),
};
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ClusterParameterGroupNameMessage {
pub parameter_group_name: Option<String>,
pub parameter_group_status: Option<String>,
}
struct ClusterParameterGroupNameMessageDeserializer;
impl ClusterParameterGroupNameMessageDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ClusterParameterGroupNameMessage, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = ClusterParameterGroupNameMessage::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"ParameterGroupName" => {
obj.parameter_group_name = Some(try!(StringDeserializer::deserialize(
"ParameterGroupName",
stack
)));
}
"ParameterGroupStatus" => {
obj.parameter_group_status = Some(try!(StringDeserializer::deserialize(
"ParameterGroupStatus",
stack
)));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ClusterParameterGroupStatus {
pub cluster_parameter_status_list: Option<Vec<ClusterParameterStatus>>,
pub parameter_apply_status: Option<String>,
pub parameter_group_name: Option<String>,
}
struct ClusterParameterGroupStatusDeserializer;
impl ClusterParameterGroupStatusDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ClusterParameterGroupStatus, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = ClusterParameterGroupStatus::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"ClusterParameterStatusList" => {
obj.cluster_parameter_status_list = match obj.cluster_parameter_status_list
{
Some(ref mut existing) => {
existing.extend(try!(
ClusterParameterStatusListDeserializer::deserialize(
"ClusterParameterStatusList",
stack
)
));
Some(existing.to_vec())
}
None => {
Some(try!(ClusterParameterStatusListDeserializer::deserialize(
"ClusterParameterStatusList",
stack
)))
}
};
}
"ParameterApplyStatus" => {
obj.parameter_apply_status = Some(try!(StringDeserializer::deserialize(
"ParameterApplyStatus",
stack
)));
}
"ParameterGroupName" => {
obj.parameter_group_name = Some(try!(StringDeserializer::deserialize(
"ParameterGroupName",
stack
)));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
struct ClusterParameterGroupStatusListDeserializer;
impl ClusterParameterGroupStatusListDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<ClusterParameterGroupStatus>, XmlParseError> {
let mut obj = vec![];
try!(start_element(tag_name, stack));
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "ClusterParameterGroup" {
obj.push(try!(ClusterParameterGroupStatusDeserializer::deserialize(
"ClusterParameterGroup",
stack
)));
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
try!(end_element(tag_name, stack));
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ClusterParameterGroupsMessage {
pub marker: Option<String>,
pub parameter_groups: Option<Vec<ClusterParameterGroup>>,
}
struct ClusterParameterGroupsMessageDeserializer;
impl ClusterParameterGroupsMessageDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ClusterParameterGroupsMessage, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = ClusterParameterGroupsMessage::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"Marker" => {
obj.marker = Some(try!(StringDeserializer::deserialize("Marker", stack)));
}
"ParameterGroups" => {
obj.parameter_groups = match obj.parameter_groups {
Some(ref mut existing) => {
existing.extend(try!(ParameterGroupListDeserializer::deserialize(
"ParameterGroups",
stack
)));
Some(existing.to_vec())
}
None => Some(try!(ParameterGroupListDeserializer::deserialize(
"ParameterGroups",
stack
))),
};
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ClusterParameterStatus {
pub parameter_apply_error_description: Option<String>,
pub parameter_apply_status: Option<String>,
pub parameter_name: Option<String>,
}
struct ClusterParameterStatusDeserializer;
impl ClusterParameterStatusDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ClusterParameterStatus, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = ClusterParameterStatus::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"ParameterApplyErrorDescription" => {
obj.parameter_apply_error_description =
Some(try!(StringDeserializer::deserialize(
"ParameterApplyErrorDescription",
stack
)));
}
"ParameterApplyStatus" => {
obj.parameter_apply_status = Some(try!(StringDeserializer::deserialize(
"ParameterApplyStatus",
stack
)));
}
"ParameterName" => {
obj.parameter_name = Some(try!(StringDeserializer::deserialize(
"ParameterName",
stack
)));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
struct ClusterParameterStatusListDeserializer;
impl ClusterParameterStatusListDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<ClusterParameterStatus>, XmlParseError> {
let mut obj = vec![];
try!(start_element(tag_name, stack));
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "member" {
obj.push(try!(ClusterParameterStatusDeserializer::deserialize(
"member", stack
)));
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
try!(end_element(tag_name, stack));
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct 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>>,
}
struct ClusterSecurityGroupDeserializer;
impl ClusterSecurityGroupDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ClusterSecurityGroup, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = ClusterSecurityGroup::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"ClusterSecurityGroupName" => {
obj.cluster_security_group_name = Some(try!(
StringDeserializer::deserialize("ClusterSecurityGroupName", stack)
));
}
"Description" => {
obj.description =
Some(try!(StringDeserializer::deserialize("Description", stack)));
}
"EC2SecurityGroups" => {
obj.ec2_security_groups = match obj.ec2_security_groups {
Some(ref mut existing) => {
existing.extend(try!(
EC2SecurityGroupListDeserializer::deserialize(
"EC2SecurityGroups",
stack
)
));
Some(existing.to_vec())
}
None => Some(try!(EC2SecurityGroupListDeserializer::deserialize(
"EC2SecurityGroups",
stack
))),
};
}
"IPRanges" => {
obj.ip_ranges = match obj.ip_ranges {
Some(ref mut existing) => {
existing.extend(try!(IPRangeListDeserializer::deserialize(
"IPRanges", stack
)));
Some(existing.to_vec())
}
None => Some(try!(IPRangeListDeserializer::deserialize(
"IPRanges", stack
))),
};
}
"Tags" => {
obj.tags = match obj.tags {
Some(ref mut existing) => {
existing
.extend(try!(TagListDeserializer::deserialize("Tags", stack)));
Some(existing.to_vec())
}
None => Some(try!(TagListDeserializer::deserialize("Tags", stack))),
};
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ClusterSecurityGroupMembership {
pub cluster_security_group_name: Option<String>,
pub status: Option<String>,
}
struct ClusterSecurityGroupMembershipDeserializer;
impl ClusterSecurityGroupMembershipDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ClusterSecurityGroupMembership, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = ClusterSecurityGroupMembership::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"ClusterSecurityGroupName" => {
obj.cluster_security_group_name = Some(try!(
StringDeserializer::deserialize("ClusterSecurityGroupName", stack)
));
}
"Status" => {
obj.status = Some(try!(StringDeserializer::deserialize("Status", stack)));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
struct ClusterSecurityGroupMembershipListDeserializer;
impl ClusterSecurityGroupMembershipListDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<ClusterSecurityGroupMembership>, XmlParseError> {
let mut obj = vec![];
try!(start_element(tag_name, stack));
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "ClusterSecurityGroup" {
obj.push(try!(
ClusterSecurityGroupMembershipDeserializer::deserialize(
"ClusterSecurityGroup",
stack
)
));
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
try!(end_element(tag_name, stack));
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ClusterSecurityGroupMessage {
pub cluster_security_groups: Option<Vec<ClusterSecurityGroup>>,
pub marker: Option<String>,
}
struct ClusterSecurityGroupMessageDeserializer;
impl ClusterSecurityGroupMessageDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ClusterSecurityGroupMessage, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = ClusterSecurityGroupMessage::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"ClusterSecurityGroups" => {
obj.cluster_security_groups = match obj.cluster_security_groups {
Some(ref mut existing) => {
existing.extend(try!(
ClusterSecurityGroupsDeserializer::deserialize(
"ClusterSecurityGroups",
stack
)
));
Some(existing.to_vec())
}
None => Some(try!(ClusterSecurityGroupsDeserializer::deserialize(
"ClusterSecurityGroups",
stack
))),
};
}
"Marker" => {
obj.marker = Some(try!(StringDeserializer::deserialize("Marker", stack)));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
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);
}
}
}
struct ClusterSecurityGroupsDeserializer;
impl ClusterSecurityGroupsDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<ClusterSecurityGroup>, XmlParseError> {
let mut obj = vec![];
try!(start_element(tag_name, stack));
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "ClusterSecurityGroup" {
obj.push(try!(ClusterSecurityGroupDeserializer::deserialize(
"ClusterSecurityGroup",
stack
)));
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
try!(end_element(tag_name, stack));
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ClusterSnapshotCopyStatus {
pub destination_region: Option<String>,
pub retention_period: Option<i64>,
pub snapshot_copy_grant_name: Option<String>,
}
struct ClusterSnapshotCopyStatusDeserializer;
impl ClusterSnapshotCopyStatusDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ClusterSnapshotCopyStatus, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = ClusterSnapshotCopyStatus::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"DestinationRegion" => {
obj.destination_region = Some(try!(StringDeserializer::deserialize(
"DestinationRegion",
stack
)));
}
"RetentionPeriod" => {
obj.retention_period = Some(try!(LongDeserializer::deserialize(
"RetentionPeriod",
stack
)));
}
"SnapshotCopyGrantName" => {
obj.snapshot_copy_grant_name = Some(try!(StringDeserializer::deserialize(
"SnapshotCopyGrantName",
stack
)));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct 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>,
}
struct ClusterSubnetGroupDeserializer;
impl ClusterSubnetGroupDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ClusterSubnetGroup, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = ClusterSubnetGroup::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"ClusterSubnetGroupName" => {
obj.cluster_subnet_group_name = Some(try!(
StringDeserializer::deserialize("ClusterSubnetGroupName", stack)
));
}
"Description" => {
obj.description =
Some(try!(StringDeserializer::deserialize("Description", stack)));
}
"SubnetGroupStatus" => {
obj.subnet_group_status = Some(try!(StringDeserializer::deserialize(
"SubnetGroupStatus",
stack
)));
}
"Subnets" => {
obj.subnets = match obj.subnets {
Some(ref mut existing) => {
existing.extend(try!(SubnetListDeserializer::deserialize(
"Subnets", stack
)));
Some(existing.to_vec())
}
None => {
Some(try!(SubnetListDeserializer::deserialize("Subnets", stack)))
}
};
}
"Tags" => {
obj.tags = match obj.tags {
Some(ref mut existing) => {
existing
.extend(try!(TagListDeserializer::deserialize("Tags", stack)));
Some(existing.to_vec())
}
None => Some(try!(TagListDeserializer::deserialize("Tags", stack))),
};
}
"VpcId" => {
obj.vpc_id = Some(try!(StringDeserializer::deserialize("VpcId", stack)));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ClusterSubnetGroupMessage {
pub cluster_subnet_groups: Option<Vec<ClusterSubnetGroup>>,
pub marker: Option<String>,
}
struct ClusterSubnetGroupMessageDeserializer;
impl ClusterSubnetGroupMessageDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ClusterSubnetGroupMessage, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = ClusterSubnetGroupMessage::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"ClusterSubnetGroups" => {
obj.cluster_subnet_groups = match obj.cluster_subnet_groups {
Some(ref mut existing) => {
existing.extend(try!(
ClusterSubnetGroupsDeserializer::deserialize(
"ClusterSubnetGroups",
stack
)
));
Some(existing.to_vec())
}
None => Some(try!(ClusterSubnetGroupsDeserializer::deserialize(
"ClusterSubnetGroups",
stack
))),
};
}
"Marker" => {
obj.marker = Some(try!(StringDeserializer::deserialize("Marker", stack)));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
struct ClusterSubnetGroupsDeserializer;
impl ClusterSubnetGroupsDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<ClusterSubnetGroup>, XmlParseError> {
let mut obj = vec![];
try!(start_element(tag_name, stack));
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "ClusterSubnetGroup" {
obj.push(try!(ClusterSubnetGroupDeserializer::deserialize(
"ClusterSubnetGroup",
stack
)));
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
try!(end_element(tag_name, stack));
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ClusterVersion {
pub cluster_parameter_group_family: Option<String>,
pub cluster_version: Option<String>,
pub description: Option<String>,
}
struct ClusterVersionDeserializer;
impl ClusterVersionDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ClusterVersion, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = ClusterVersion::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"ClusterParameterGroupFamily" => {
obj.cluster_parameter_group_family = Some(try!(
StringDeserializer::deserialize("ClusterParameterGroupFamily", stack)
));
}
"ClusterVersion" => {
obj.cluster_version = Some(try!(StringDeserializer::deserialize(
"ClusterVersion",
stack
)));
}
"Description" => {
obj.description =
Some(try!(StringDeserializer::deserialize("Description", stack)));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
struct ClusterVersionListDeserializer;
impl ClusterVersionListDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<ClusterVersion>, XmlParseError> {
let mut obj = vec![];
try!(start_element(tag_name, stack));
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "ClusterVersion" {
obj.push(try!(ClusterVersionDeserializer::deserialize(
"ClusterVersion",
stack
)));
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
try!(end_element(tag_name, stack));
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ClusterVersionsMessage {
pub cluster_versions: Option<Vec<ClusterVersion>>,
pub marker: Option<String>,
}
struct ClusterVersionsMessageDeserializer;
impl ClusterVersionsMessageDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ClusterVersionsMessage, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = ClusterVersionsMessage::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"ClusterVersions" => {
obj.cluster_versions = match obj.cluster_versions {
Some(ref mut existing) => {
existing.extend(try!(ClusterVersionListDeserializer::deserialize(
"ClusterVersions",
stack
)));
Some(existing.to_vec())
}
None => Some(try!(ClusterVersionListDeserializer::deserialize(
"ClusterVersions",
stack
))),
};
}
"Marker" => {
obj.marker = Some(try!(StringDeserializer::deserialize("Marker", stack)));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ClustersMessage {
pub clusters: Option<Vec<Cluster>>,
pub marker: Option<String>,
}
struct ClustersMessageDeserializer;
impl ClustersMessageDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ClustersMessage, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = ClustersMessage::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"Clusters" => {
obj.clusters = match obj.clusters {
Some(ref mut existing) => {
existing.extend(try!(ClusterListDeserializer::deserialize(
"Clusters", stack
)));
Some(existing.to_vec())
}
None => Some(try!(ClusterListDeserializer::deserialize(
"Clusters", stack
))),
};
}
"Marker" => {
obj.marker = Some(try!(StringDeserializer::deserialize("Marker", stack)));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CopyClusterSnapshotMessage {
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.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(Default, Debug, Clone, PartialEq)]
pub struct CopyClusterSnapshotResult {
pub snapshot: Option<Snapshot>,
}
struct CopyClusterSnapshotResultDeserializer;
impl CopyClusterSnapshotResultDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CopyClusterSnapshotResult, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = CopyClusterSnapshotResult::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"Snapshot" => {
obj.snapshot =
Some(try!(SnapshotDeserializer::deserialize("Snapshot", stack)));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct 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 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 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.to_string(),
);
}
if let Some(ref field_value) = obj.automated_snapshot_retention_period {
params.put(
&format!("{}{}", prefix, "AutomatedSnapshotRetentionPeriod"),
&field_value.to_string(),
);
}
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.to_string(),
);
}
if let Some(ref field_value) = obj.enhanced_vpc_routing {
params.put(
&format!("{}{}", prefix, "EnhancedVpcRouting"),
&field_value.to_string(),
);
}
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,
);
}
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.to_string(),
);
}
if let Some(ref field_value) = obj.port {
params.put(&format!("{}{}", prefix, "Port"), &field_value.to_string());
}
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.to_string(),
);
}
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(Default, Debug, Clone, PartialEq)]
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(Default, Debug, Clone, PartialEq)]
pub struct CreateClusterParameterGroupResult {
pub cluster_parameter_group: Option<ClusterParameterGroup>,
}
struct CreateClusterParameterGroupResultDeserializer;
impl CreateClusterParameterGroupResultDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CreateClusterParameterGroupResult, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = CreateClusterParameterGroupResult::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"ClusterParameterGroup" => {
obj.cluster_parameter_group =
Some(try!(ClusterParameterGroupDeserializer::deserialize(
"ClusterParameterGroup",
stack
)));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateClusterResult {
pub cluster: Option<Cluster>,
}
struct CreateClusterResultDeserializer;
impl CreateClusterResultDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CreateClusterResult, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = CreateClusterResult::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"Cluster" => {
obj.cluster =
Some(try!(ClusterDeserializer::deserialize("Cluster", stack)));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct 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(Default, Debug, Clone, PartialEq)]
pub struct CreateClusterSecurityGroupResult {
pub cluster_security_group: Option<ClusterSecurityGroup>,
}
struct CreateClusterSecurityGroupResultDeserializer;
impl CreateClusterSecurityGroupResultDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CreateClusterSecurityGroupResult, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = CreateClusterSecurityGroupResult::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"ClusterSecurityGroup" => {
obj.cluster_security_group =
Some(try!(ClusterSecurityGroupDeserializer::deserialize(
"ClusterSecurityGroup",
stack
)));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateClusterSnapshotMessage {
pub cluster_identifier: String,
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,
);
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(Default, Debug, Clone, PartialEq)]
pub struct CreateClusterSnapshotResult {
pub snapshot: Option<Snapshot>,
}
struct CreateClusterSnapshotResultDeserializer;
impl CreateClusterSnapshotResultDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CreateClusterSnapshotResult, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = CreateClusterSnapshotResult::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"Snapshot" => {
obj.snapshot =
Some(try!(SnapshotDeserializer::deserialize("Snapshot", stack)));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct 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(Default, Debug, Clone, PartialEq)]
pub struct CreateClusterSubnetGroupResult {
pub cluster_subnet_group: Option<ClusterSubnetGroup>,
}
struct CreateClusterSubnetGroupResultDeserializer;
impl CreateClusterSubnetGroupResultDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CreateClusterSubnetGroupResult, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = CreateClusterSubnetGroupResult::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"ClusterSubnetGroup" => {
obj.cluster_subnet_group =
Some(try!(ClusterSubnetGroupDeserializer::deserialize(
"ClusterSubnetGroup",
stack
)));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct 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.to_string(),
);
}
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(Default, Debug, Clone, PartialEq)]
pub struct CreateEventSubscriptionResult {
pub event_subscription: Option<EventSubscription>,
}
struct CreateEventSubscriptionResultDeserializer;
impl CreateEventSubscriptionResultDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CreateEventSubscriptionResult, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = CreateEventSubscriptionResult::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"EventSubscription" => {
obj.event_subscription = Some(try!(
EventSubscriptionDeserializer::deserialize("EventSubscription", stack)
));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct 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(Default, Debug, Clone, PartialEq)]
pub struct CreateHsmClientCertificateResult {
pub hsm_client_certificate: Option<HsmClientCertificate>,
}
struct CreateHsmClientCertificateResultDeserializer;
impl CreateHsmClientCertificateResultDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CreateHsmClientCertificateResult, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = CreateHsmClientCertificateResult::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"HsmClientCertificate" => {
obj.hsm_client_certificate =
Some(try!(HsmClientCertificateDeserializer::deserialize(
"HsmClientCertificate",
stack
)));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct 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(Default, Debug, Clone, PartialEq)]
pub struct CreateHsmConfigurationResult {
pub hsm_configuration: Option<HsmConfiguration>,
}
struct CreateHsmConfigurationResultDeserializer;
impl CreateHsmConfigurationResultDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CreateHsmConfigurationResult, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = CreateHsmConfigurationResult::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"HsmConfiguration" => {
obj.hsm_configuration = Some(try!(
HsmConfigurationDeserializer::deserialize("HsmConfiguration", stack)
));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct 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(Default, Debug, Clone, PartialEq)]
pub struct CreateSnapshotCopyGrantResult {
pub snapshot_copy_grant: Option<SnapshotCopyGrant>,
}
struct CreateSnapshotCopyGrantResultDeserializer;
impl CreateSnapshotCopyGrantResultDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CreateSnapshotCopyGrantResult, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = CreateSnapshotCopyGrantResult::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"SnapshotCopyGrant" => {
obj.snapshot_copy_grant = Some(try!(
SnapshotCopyGrantDeserializer::deserialize("SnapshotCopyGrant", stack)
));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct 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);
}
}
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(Default, Debug, Clone, PartialEq)]
pub struct DefaultClusterParameters {
pub marker: Option<String>,
pub parameter_group_family: Option<String>,
pub parameters: Option<Vec<Parameter>>,
}
struct DefaultClusterParametersDeserializer;
impl DefaultClusterParametersDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DefaultClusterParameters, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = DefaultClusterParameters::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"Marker" => {
obj.marker = Some(try!(StringDeserializer::deserialize("Marker", stack)));
}
"ParameterGroupFamily" => {
obj.parameter_group_family = Some(try!(StringDeserializer::deserialize(
"ParameterGroupFamily",
stack
)));
}
"Parameters" => {
obj.parameters = match obj.parameters {
Some(ref mut existing) => {
existing.extend(try!(ParametersListDeserializer::deserialize(
"Parameters",
stack
)));
Some(existing.to_vec())
}
None => Some(try!(ParametersListDeserializer::deserialize(
"Parameters",
stack
))),
};
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DeleteClusterMessage {
pub cluster_identifier: String,
pub final_cluster_snapshot_identifier: Option<String>,
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.skip_final_cluster_snapshot {
params.put(
&format!("{}{}", prefix, "SkipFinalClusterSnapshot"),
&field_value.to_string(),
);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
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(Default, Debug, Clone, PartialEq)]
pub struct DeleteClusterResult {
pub cluster: Option<Cluster>,
}
struct DeleteClusterResultDeserializer;
impl DeleteClusterResultDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DeleteClusterResult, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = DeleteClusterResult::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"Cluster" => {
obj.cluster =
Some(try!(ClusterDeserializer::deserialize("Cluster", stack)));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct 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(Default, Debug, Clone, PartialEq)]
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,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DeleteClusterSnapshotResult {
pub snapshot: Option<Snapshot>,
}
struct DeleteClusterSnapshotResultDeserializer;
impl DeleteClusterSnapshotResultDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DeleteClusterSnapshotResult, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = DeleteClusterSnapshotResult::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"Snapshot" => {
obj.snapshot =
Some(try!(SnapshotDeserializer::deserialize("Snapshot", stack)));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct 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(Default, Debug, Clone, PartialEq)]
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(Default, Debug, Clone, PartialEq)]
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(Default, Debug, Clone, PartialEq)]
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(Default, Debug, Clone, PartialEq)]
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(Default, Debug, Clone, PartialEq)]
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(Default, Debug, Clone, PartialEq)]
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.to_string(),
);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
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.to_string(),
);
}
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(Default, Debug, Clone, PartialEq)]
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.to_string(),
);
}
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(Default, Debug, Clone, PartialEq)]
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.to_string(),
);
}
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(Default, Debug, Clone, PartialEq)]
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 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.to_string(),
);
}
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.to_string(),
);
}
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.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(Default, Debug, Clone, PartialEq)]
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.to_string(),
);
}
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(Default, Debug, Clone, PartialEq)]
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.to_string(),
);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
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.to_string(),
);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
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.to_string(),
);
}
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(Default, Debug, Clone, PartialEq)]
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.to_string(),
);
}
params.put(
&format!("{}{}", prefix, "ParameterGroupFamily"),
&obj.parameter_group_family,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeDefaultClusterParametersResult {
pub default_cluster_parameters: Option<DefaultClusterParameters>,
}
struct DescribeDefaultClusterParametersResultDeserializer;
impl DescribeDefaultClusterParametersResultDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeDefaultClusterParametersResult, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = DescribeDefaultClusterParametersResult::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"DefaultClusterParameters" => {
obj.default_cluster_parameters =
Some(try!(DefaultClusterParametersDeserializer::deserialize(
"DefaultClusterParameters",
stack
)));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct 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(Default, Debug, Clone, PartialEq)]
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.to_string(),
);
}
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(Default, Debug, Clone, PartialEq)]
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.to_string(),
);
}
if let Some(ref field_value) = obj.end_time {
params.put(&format!("{}{}", prefix, "EndTime"), &field_value);
}
if let Some(ref field_value) = obj.marker {
params.put(&format!("{}{}", prefix, "Marker"), &field_value);
}
if let Some(ref field_value) = obj.max_records {
params.put(
&format!("{}{}", prefix, "MaxRecords"),
&field_value.to_string(),
);
}
if let Some(ref field_value) = obj.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(Default, Debug, Clone, PartialEq)]
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.to_string(),
);
}
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(Default, Debug, Clone, PartialEq)]
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.to_string(),
);
}
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(Default, Debug, Clone, PartialEq)]
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(Default, Debug, Clone, PartialEq)]
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.to_string(),
);
}
if let Some(ref field_value) = obj.node_type {
params.put(&format!("{}{}", prefix, "NodeType"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
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.to_string(),
);
}
if let Some(ref field_value) = obj.reserved_node_offering_id {
params.put(
&format!("{}{}", prefix, "ReservedNodeOfferingId"),
&field_value,
);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
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.to_string(),
);
}
if let Some(ref field_value) = obj.reserved_node_id {
params.put(&format!("{}{}", prefix, "ReservedNodeId"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
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(Default, Debug, Clone, PartialEq)]
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.to_string(),
);
}
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(Default, Debug, Clone, PartialEq)]
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.to_string(),
);
}
if let Some(ref field_value) = obj.table_restore_request_id {
params.put(
&format!("{}{}", prefix, "TableRestoreRequestId"),
&field_value,
);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
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.to_string(),
);
}
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(Default, Debug, Clone, PartialEq)]
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(Default, Debug, Clone, PartialEq)]
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(Default, Debug, Clone, PartialEq)]
pub struct DisableSnapshotCopyResult {
pub cluster: Option<Cluster>,
}
struct DisableSnapshotCopyResultDeserializer;
impl DisableSnapshotCopyResultDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DisableSnapshotCopyResult, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = DisableSnapshotCopyResult::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"Cluster" => {
obj.cluster =
Some(try!(ClusterDeserializer::deserialize("Cluster", stack)));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
struct DoubleDeserializer;
impl DoubleDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<f64, XmlParseError> {
try!(start_element(tag_name, stack));
let obj = f64::from_str(try!(characters(stack)).as_ref()).unwrap();
try!(end_element(tag_name, stack));
Ok(obj)
}
}
struct DoubleOptionalDeserializer;
impl DoubleOptionalDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<f64, XmlParseError> {
try!(start_element(tag_name, stack));
let obj = f64::from_str(try!(characters(stack)).as_ref()).unwrap();
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
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>>,
}
struct EC2SecurityGroupDeserializer;
impl EC2SecurityGroupDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<EC2SecurityGroup, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = EC2SecurityGroup::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"EC2SecurityGroupName" => {
obj.ec2_security_group_name = Some(try!(StringDeserializer::deserialize(
"EC2SecurityGroupName",
stack
)));
}
"EC2SecurityGroupOwnerId" => {
obj.ec2_security_group_owner_id = Some(try!(
StringDeserializer::deserialize("EC2SecurityGroupOwnerId", stack)
));
}
"Status" => {
obj.status = Some(try!(StringDeserializer::deserialize("Status", stack)));
}
"Tags" => {
obj.tags = match obj.tags {
Some(ref mut existing) => {
existing
.extend(try!(TagListDeserializer::deserialize("Tags", stack)));
Some(existing.to_vec())
}
None => Some(try!(TagListDeserializer::deserialize("Tags", stack))),
};
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
struct EC2SecurityGroupListDeserializer;
impl EC2SecurityGroupListDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<EC2SecurityGroup>, XmlParseError> {
let mut obj = vec![];
try!(start_element(tag_name, stack));
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "EC2SecurityGroup" {
obj.push(try!(EC2SecurityGroupDeserializer::deserialize(
"EC2SecurityGroup",
stack
)));
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
try!(end_element(tag_name, stack));
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ElasticIpStatus {
pub elastic_ip: Option<String>,
pub status: Option<String>,
}
struct ElasticIpStatusDeserializer;
impl ElasticIpStatusDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ElasticIpStatus, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = ElasticIpStatus::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"ElasticIp" => {
obj.elastic_ip =
Some(try!(StringDeserializer::deserialize("ElasticIp", stack)));
}
"Status" => {
obj.status = Some(try!(StringDeserializer::deserialize("Status", stack)));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
struct EligibleTracksToUpdateListDeserializer;
impl EligibleTracksToUpdateListDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<UpdateTarget>, XmlParseError> {
let mut obj = vec![];
try!(start_element(tag_name, stack));
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "UpdateTarget" {
obj.push(try!(UpdateTargetDeserializer::deserialize(
"UpdateTarget",
stack
)));
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
try!(end_element(tag_name, stack));
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct 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(Default, Debug, Clone, PartialEq)]
pub struct EnableSnapshotCopyMessage {
pub cluster_identifier: String,
pub destination_region: String,
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.retention_period {
params.put(
&format!("{}{}", prefix, "RetentionPeriod"),
&field_value.to_string(),
);
}
if let Some(ref field_value) = obj.snapshot_copy_grant_name {
params.put(
&format!("{}{}", prefix, "SnapshotCopyGrantName"),
&field_value,
);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct EnableSnapshotCopyResult {
pub cluster: Option<Cluster>,
}
struct EnableSnapshotCopyResultDeserializer;
impl EnableSnapshotCopyResultDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<EnableSnapshotCopyResult, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = EnableSnapshotCopyResult::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"Cluster" => {
obj.cluster =
Some(try!(ClusterDeserializer::deserialize("Cluster", stack)));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct Endpoint {
pub address: Option<String>,
pub port: Option<i64>,
}
struct EndpointDeserializer;
impl EndpointDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Endpoint, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = Endpoint::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"Address" => {
obj.address = Some(try!(StringDeserializer::deserialize("Address", stack)));
}
"Port" => {
obj.port = Some(try!(IntegerDeserializer::deserialize("Port", stack)));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct 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>,
}
struct EventDeserializer;
impl EventDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Event, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = Event::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"Date" => {
obj.date = Some(try!(TStampDeserializer::deserialize("Date", stack)));
}
"EventCategories" => {
obj.event_categories = match obj.event_categories {
Some(ref mut existing) => {
existing.extend(try!(
EventCategoriesListDeserializer::deserialize(
"EventCategories",
stack
)
));
Some(existing.to_vec())
}
None => Some(try!(EventCategoriesListDeserializer::deserialize(
"EventCategories",
stack
))),
};
}
"EventId" => {
obj.event_id =
Some(try!(StringDeserializer::deserialize("EventId", stack)));
}
"Message" => {
obj.message = Some(try!(StringDeserializer::deserialize("Message", stack)));
}
"Severity" => {
obj.severity =
Some(try!(StringDeserializer::deserialize("Severity", stack)));
}
"SourceIdentifier" => {
obj.source_identifier = Some(try!(StringDeserializer::deserialize(
"SourceIdentifier",
stack
)));
}
"SourceType" => {
obj.source_type = Some(try!(SourceTypeDeserializer::deserialize(
"SourceType",
stack
)));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
struct EventCategoriesListDeserializer;
impl EventCategoriesListDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<String>, XmlParseError> {
let mut obj = vec![];
try!(start_element(tag_name, stack));
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "EventCategory" {
obj.push(try!(StringDeserializer::deserialize(
"EventCategory",
stack
)));
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
try!(end_element(tag_name, stack));
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
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(Default, Debug, Clone, PartialEq)]
pub struct EventCategoriesMap {
pub events: Option<Vec<EventInfoMap>>,
pub source_type: Option<String>,
}
struct EventCategoriesMapDeserializer;
impl EventCategoriesMapDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<EventCategoriesMap, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = EventCategoriesMap::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"Events" => {
obj.events = match obj.events {
Some(ref mut existing) => {
existing.extend(try!(EventInfoMapListDeserializer::deserialize(
"Events", stack
)));
Some(existing.to_vec())
}
None => Some(try!(EventInfoMapListDeserializer::deserialize(
"Events", stack
))),
};
}
"SourceType" => {
obj.source_type =
Some(try!(StringDeserializer::deserialize("SourceType", stack)));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
struct EventCategoriesMapListDeserializer;
impl EventCategoriesMapListDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<EventCategoriesMap>, XmlParseError> {
let mut obj = vec![];
try!(start_element(tag_name, stack));
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "EventCategoriesMap" {
obj.push(try!(EventCategoriesMapDeserializer::deserialize(
"EventCategoriesMap",
stack
)));
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
try!(end_element(tag_name, stack));
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct EventCategoriesMessage {
pub event_categories_map_list: Option<Vec<EventCategoriesMap>>,
}
struct EventCategoriesMessageDeserializer;
impl EventCategoriesMessageDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<EventCategoriesMessage, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = EventCategoriesMessage::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"EventCategoriesMapList" => {
obj.event_categories_map_list = match obj.event_categories_map_list {
Some(ref mut existing) => {
existing.extend(try!(
EventCategoriesMapListDeserializer::deserialize(
"EventCategoriesMapList",
stack
)
));
Some(existing.to_vec())
}
None => Some(try!(EventCategoriesMapListDeserializer::deserialize(
"EventCategoriesMapList",
stack
))),
};
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct EventInfoMap {
pub event_categories: Option<Vec<String>>,
pub event_description: Option<String>,
pub event_id: Option<String>,
pub severity: Option<String>,
}
struct EventInfoMapDeserializer;
impl EventInfoMapDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<EventInfoMap, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = EventInfoMap::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"EventCategories" => {
obj.event_categories = match obj.event_categories {
Some(ref mut existing) => {
existing.extend(try!(
EventCategoriesListDeserializer::deserialize(
"EventCategories",
stack
)
));
Some(existing.to_vec())
}
None => Some(try!(EventCategoriesListDeserializer::deserialize(
"EventCategories",
stack
))),
};
}
"EventDescription" => {
obj.event_description = Some(try!(StringDeserializer::deserialize(
"EventDescription",
stack
)));
}
"EventId" => {
obj.event_id =
Some(try!(StringDeserializer::deserialize("EventId", stack)));
}
"Severity" => {
obj.severity =
Some(try!(StringDeserializer::deserialize("Severity", stack)));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
struct EventInfoMapListDeserializer;
impl EventInfoMapListDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<EventInfoMap>, XmlParseError> {
let mut obj = vec![];
try!(start_element(tag_name, stack));
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "EventInfoMap" {
obj.push(try!(EventInfoMapDeserializer::deserialize(
"EventInfoMap",
stack
)));
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
try!(end_element(tag_name, stack));
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
struct EventListDeserializer;
impl EventListDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<Event>, XmlParseError> {
let mut obj = vec![];
try!(start_element(tag_name, stack));
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "Event" {
obj.push(try!(EventDeserializer::deserialize("Event", stack)));
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
try!(end_element(tag_name, stack));
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct 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>>,
}
struct EventSubscriptionDeserializer;
impl EventSubscriptionDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<EventSubscription, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = EventSubscription::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"CustSubscriptionId" => {
obj.cust_subscription_id = Some(try!(StringDeserializer::deserialize(
"CustSubscriptionId",
stack
)));
}
"CustomerAwsId" => {
obj.customer_aws_id = Some(try!(StringDeserializer::deserialize(
"CustomerAwsId",
stack
)));
}
"Enabled" => {
obj.enabled =
Some(try!(BooleanDeserializer::deserialize("Enabled", stack)));
}
"EventCategoriesList" => {
obj.event_categories_list = match obj.event_categories_list {
Some(ref mut existing) => {
existing.extend(try!(
EventCategoriesListDeserializer::deserialize(
"EventCategoriesList",
stack
)
));
Some(existing.to_vec())
}
None => Some(try!(EventCategoriesListDeserializer::deserialize(
"EventCategoriesList",
stack
))),
};
}
"Severity" => {
obj.severity =
Some(try!(StringDeserializer::deserialize("Severity", stack)));
}
"SnsTopicArn" => {
obj.sns_topic_arn =
Some(try!(StringDeserializer::deserialize("SnsTopicArn", stack)));
}
"SourceIdsList" => {
obj.source_ids_list = match obj.source_ids_list {
Some(ref mut existing) => {
existing.extend(try!(SourceIdsListDeserializer::deserialize(
"SourceIdsList",
stack
)));
Some(existing.to_vec())
}
None => Some(try!(SourceIdsListDeserializer::deserialize(
"SourceIdsList",
stack
))),
};
}
"SourceType" => {
obj.source_type =
Some(try!(StringDeserializer::deserialize("SourceType", stack)));
}
"Status" => {
obj.status = Some(try!(StringDeserializer::deserialize("Status", stack)));
}
"SubscriptionCreationTime" => {
obj.subscription_creation_time = Some(try!(
TStampDeserializer::deserialize("SubscriptionCreationTime", stack)
));
}
"Tags" => {
obj.tags = match obj.tags {
Some(ref mut existing) => {
existing
.extend(try!(TagListDeserializer::deserialize("Tags", stack)));
Some(existing.to_vec())
}
None => Some(try!(TagListDeserializer::deserialize("Tags", stack))),
};
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
struct EventSubscriptionsListDeserializer;
impl EventSubscriptionsListDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<EventSubscription>, XmlParseError> {
let mut obj = vec![];
try!(start_element(tag_name, stack));
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "EventSubscription" {
obj.push(try!(EventSubscriptionDeserializer::deserialize(
"EventSubscription",
stack
)));
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
try!(end_element(tag_name, stack));
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct EventSubscriptionsMessage {
pub event_subscriptions_list: Option<Vec<EventSubscription>>,
pub marker: Option<String>,
}
struct EventSubscriptionsMessageDeserializer;
impl EventSubscriptionsMessageDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<EventSubscriptionsMessage, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = EventSubscriptionsMessage::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"EventSubscriptionsList" => {
obj.event_subscriptions_list = match obj.event_subscriptions_list {
Some(ref mut existing) => {
existing.extend(try!(
EventSubscriptionsListDeserializer::deserialize(
"EventSubscriptionsList",
stack
)
));
Some(existing.to_vec())
}
None => Some(try!(EventSubscriptionsListDeserializer::deserialize(
"EventSubscriptionsList",
stack
))),
};
}
"Marker" => {
obj.marker = Some(try!(StringDeserializer::deserialize("Marker", stack)));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct EventsMessage {
pub events: Option<Vec<Event>>,
pub marker: Option<String>,
}
struct EventsMessageDeserializer;
impl EventsMessageDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<EventsMessage, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = EventsMessage::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"Events" => {
obj.events = match obj.events {
Some(ref mut existing) => {
existing.extend(try!(EventListDeserializer::deserialize(
"Events", stack
)));
Some(existing.to_vec())
}
None => Some(try!(EventListDeserializer::deserialize("Events", stack))),
};
}
"Marker" => {
obj.marker = Some(try!(StringDeserializer::deserialize("Marker", stack)));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct 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.to_string(),
);
}
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.to_string(),
);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
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.to_string(),
);
}
params.put(
&format!("{}{}", prefix, "ReservedNodeId"),
&obj.reserved_node_id,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct GetReservedNodeExchangeOfferingsOutputMessage {
pub marker: Option<String>,
pub reserved_node_offerings: Option<Vec<ReservedNodeOffering>>,
}
struct GetReservedNodeExchangeOfferingsOutputMessageDeserializer;
impl GetReservedNodeExchangeOfferingsOutputMessageDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<GetReservedNodeExchangeOfferingsOutputMessage, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = GetReservedNodeExchangeOfferingsOutputMessage::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"Marker" => {
obj.marker = Some(try!(StringDeserializer::deserialize("Marker", stack)));
}
"ReservedNodeOfferings" => {
obj.reserved_node_offerings = match obj.reserved_node_offerings {
Some(ref mut existing) => {
existing.extend(try!(
ReservedNodeOfferingListDeserializer::deserialize(
"ReservedNodeOfferings",
stack
)
));
Some(existing.to_vec())
}
None => Some(try!(ReservedNodeOfferingListDeserializer::deserialize(
"ReservedNodeOfferings",
stack
))),
};
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct HsmClientCertificate {
pub hsm_client_certificate_identifier: Option<String>,
pub hsm_client_certificate_public_key: Option<String>,
pub tags: Option<Vec<Tag>>,
}
struct HsmClientCertificateDeserializer;
impl HsmClientCertificateDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<HsmClientCertificate, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = HsmClientCertificate::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"HsmClientCertificateIdentifier" => {
obj.hsm_client_certificate_identifier =
Some(try!(StringDeserializer::deserialize(
"HsmClientCertificateIdentifier",
stack
)));
}
"HsmClientCertificatePublicKey" => {
obj.hsm_client_certificate_public_key = Some(try!(
StringDeserializer::deserialize("HsmClientCertificatePublicKey", stack)
));
}
"Tags" => {
obj.tags = match obj.tags {
Some(ref mut existing) => {
existing
.extend(try!(TagListDeserializer::deserialize("Tags", stack)));
Some(existing.to_vec())
}
None => Some(try!(TagListDeserializer::deserialize("Tags", stack))),
};
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
struct HsmClientCertificateListDeserializer;
impl HsmClientCertificateListDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<HsmClientCertificate>, XmlParseError> {
let mut obj = vec![];
try!(start_element(tag_name, stack));
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "HsmClientCertificate" {
obj.push(try!(HsmClientCertificateDeserializer::deserialize(
"HsmClientCertificate",
stack
)));
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
try!(end_element(tag_name, stack));
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct HsmClientCertificateMessage {
pub hsm_client_certificates: Option<Vec<HsmClientCertificate>>,
pub marker: Option<String>,
}
struct HsmClientCertificateMessageDeserializer;
impl HsmClientCertificateMessageDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<HsmClientCertificateMessage, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = HsmClientCertificateMessage::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"HsmClientCertificates" => {
obj.hsm_client_certificates = match obj.hsm_client_certificates {
Some(ref mut existing) => {
existing.extend(try!(
HsmClientCertificateListDeserializer::deserialize(
"HsmClientCertificates",
stack
)
));
Some(existing.to_vec())
}
None => Some(try!(HsmClientCertificateListDeserializer::deserialize(
"HsmClientCertificates",
stack
))),
};
}
"Marker" => {
obj.marker = Some(try!(StringDeserializer::deserialize("Marker", stack)));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct 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>>,
}
struct HsmConfigurationDeserializer;
impl HsmConfigurationDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<HsmConfiguration, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = HsmConfiguration::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"Description" => {
obj.description =
Some(try!(StringDeserializer::deserialize("Description", stack)));
}
"HsmConfigurationIdentifier" => {
obj.hsm_configuration_identifier = Some(try!(
StringDeserializer::deserialize("HsmConfigurationIdentifier", stack)
));
}
"HsmIpAddress" => {
obj.hsm_ip_address =
Some(try!(StringDeserializer::deserialize("HsmIpAddress", stack)));
}
"HsmPartitionName" => {
obj.hsm_partition_name = Some(try!(StringDeserializer::deserialize(
"HsmPartitionName",
stack
)));
}
"Tags" => {
obj.tags = match obj.tags {
Some(ref mut existing) => {
existing
.extend(try!(TagListDeserializer::deserialize("Tags", stack)));
Some(existing.to_vec())
}
None => Some(try!(TagListDeserializer::deserialize("Tags", stack))),
};
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
struct HsmConfigurationListDeserializer;
impl HsmConfigurationListDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<HsmConfiguration>, XmlParseError> {
let mut obj = vec![];
try!(start_element(tag_name, stack));
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "HsmConfiguration" {
obj.push(try!(HsmConfigurationDeserializer::deserialize(
"HsmConfiguration",
stack
)));
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
try!(end_element(tag_name, stack));
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct HsmConfigurationMessage {
pub hsm_configurations: Option<Vec<HsmConfiguration>>,
pub marker: Option<String>,
}
struct HsmConfigurationMessageDeserializer;
impl HsmConfigurationMessageDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<HsmConfigurationMessage, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = HsmConfigurationMessage::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"HsmConfigurations" => {
obj.hsm_configurations = match obj.hsm_configurations {
Some(ref mut existing) => {
existing.extend(try!(
HsmConfigurationListDeserializer::deserialize(
"HsmConfigurations",
stack
)
));
Some(existing.to_vec())
}
None => Some(try!(HsmConfigurationListDeserializer::deserialize(
"HsmConfigurations",
stack
))),
};
}
"Marker" => {
obj.marker = Some(try!(StringDeserializer::deserialize("Marker", stack)));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct HsmStatus {
pub hsm_client_certificate_identifier: Option<String>,
pub hsm_configuration_identifier: Option<String>,
pub status: Option<String>,
}
struct HsmStatusDeserializer;
impl HsmStatusDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<HsmStatus, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = HsmStatus::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"HsmClientCertificateIdentifier" => {
obj.hsm_client_certificate_identifier =
Some(try!(StringDeserializer::deserialize(
"HsmClientCertificateIdentifier",
stack
)));
}
"HsmConfigurationIdentifier" => {
obj.hsm_configuration_identifier = Some(try!(
StringDeserializer::deserialize("HsmConfigurationIdentifier", stack)
));
}
"Status" => {
obj.status = Some(try!(StringDeserializer::deserialize("Status", stack)));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct IPRange {
pub cidrip: Option<String>,
pub status: Option<String>,
pub tags: Option<Vec<Tag>>,
}
struct IPRangeDeserializer;
impl IPRangeDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<IPRange, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = IPRange::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"CIDRIP" => {
obj.cidrip = Some(try!(StringDeserializer::deserialize("CIDRIP", stack)));
}
"Status" => {
obj.status = Some(try!(StringDeserializer::deserialize("Status", stack)));
}
"Tags" => {
obj.tags = match obj.tags {
Some(ref mut existing) => {
existing
.extend(try!(TagListDeserializer::deserialize("Tags", stack)));
Some(existing.to_vec())
}
None => Some(try!(TagListDeserializer::deserialize("Tags", stack))),
};
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
struct IPRangeListDeserializer;
impl IPRangeListDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<IPRange>, XmlParseError> {
let mut obj = vec![];
try!(start_element(tag_name, stack));
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "IPRange" {
obj.push(try!(IPRangeDeserializer::deserialize("IPRange", stack)));
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
try!(end_element(tag_name, stack));
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
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);
}
}
}
struct ImportTablesCompletedDeserializer;
impl ImportTablesCompletedDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<String>, XmlParseError> {
let mut obj = vec![];
try!(start_element(tag_name, stack));
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "member" {
obj.push(try!(StringDeserializer::deserialize("member", stack)));
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
try!(end_element(tag_name, stack));
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
struct ImportTablesInProgressDeserializer;
impl ImportTablesInProgressDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<String>, XmlParseError> {
let mut obj = vec![];
try!(start_element(tag_name, stack));
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "member" {
obj.push(try!(StringDeserializer::deserialize("member", stack)));
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
try!(end_element(tag_name, stack));
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
struct ImportTablesNotStartedDeserializer;
impl ImportTablesNotStartedDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<String>, XmlParseError> {
let mut obj = vec![];
try!(start_element(tag_name, stack));
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "member" {
obj.push(try!(StringDeserializer::deserialize("member", stack)));
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
try!(end_element(tag_name, stack));
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
struct IntegerDeserializer;
impl IntegerDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<i64, XmlParseError> {
try!(start_element(tag_name, stack));
let obj = i64::from_str(try!(characters(stack)).as_ref()).unwrap();
try!(end_element(tag_name, stack));
Ok(obj)
}
}
struct IntegerOptionalDeserializer;
impl IntegerOptionalDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<i64, XmlParseError> {
try!(start_element(tag_name, stack));
let obj = i64::from_str(try!(characters(stack)).as_ref()).unwrap();
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct 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>,
}
struct LoggingStatusDeserializer;
impl LoggingStatusDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<LoggingStatus, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = LoggingStatus::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"BucketName" => {
obj.bucket_name =
Some(try!(StringDeserializer::deserialize("BucketName", stack)));
}
"LastFailureMessage" => {
obj.last_failure_message = Some(try!(StringDeserializer::deserialize(
"LastFailureMessage",
stack
)));
}
"LastFailureTime" => {
obj.last_failure_time = Some(try!(TStampDeserializer::deserialize(
"LastFailureTime",
stack
)));
}
"LastSuccessfulDeliveryTime" => {
obj.last_successful_delivery_time = Some(try!(
TStampDeserializer::deserialize("LastSuccessfulDeliveryTime", stack)
));
}
"LoggingEnabled" => {
obj.logging_enabled = Some(try!(BooleanDeserializer::deserialize(
"LoggingEnabled",
stack
)));
}
"S3KeyPrefix" => {
obj.s3_key_prefix =
Some(try!(StringDeserializer::deserialize("S3KeyPrefix", stack)));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
struct LongDeserializer;
impl LongDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<i64, XmlParseError> {
try!(start_element(tag_name, stack));
let obj = i64::from_str(try!(characters(stack)).as_ref()).unwrap();
try!(end_element(tag_name, stack));
Ok(obj)
}
}
struct LongOptionalDeserializer;
impl LongOptionalDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<i64, XmlParseError> {
try!(start_element(tag_name, stack));
let obj = i64::from_str(try!(characters(stack)).as_ref()).unwrap();
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct MaintenanceTrack {
pub database_version: Option<String>,
pub maintenance_track_name: Option<String>,
pub update_targets: Option<Vec<UpdateTarget>>,
}
struct MaintenanceTrackDeserializer;
impl MaintenanceTrackDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<MaintenanceTrack, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = MaintenanceTrack::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"DatabaseVersion" => {
obj.database_version = Some(try!(StringDeserializer::deserialize(
"DatabaseVersion",
stack
)));
}
"MaintenanceTrackName" => {
obj.maintenance_track_name = Some(try!(StringDeserializer::deserialize(
"MaintenanceTrackName",
stack
)));
}
"UpdateTargets" => {
obj.update_targets = match obj.update_targets {
Some(ref mut existing) => {
existing.extend(try!(
EligibleTracksToUpdateListDeserializer::deserialize(
"UpdateTargets",
stack
)
));
Some(existing.to_vec())
}
None => {
Some(try!(EligibleTracksToUpdateListDeserializer::deserialize(
"UpdateTargets",
stack
)))
}
};
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct 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(Default, Debug, Clone, PartialEq)]
pub struct ModifyClusterDbRevisionResult {
pub cluster: Option<Cluster>,
}
struct ModifyClusterDbRevisionResultDeserializer;
impl ModifyClusterDbRevisionResultDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ModifyClusterDbRevisionResult, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = ModifyClusterDbRevisionResult::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"Cluster" => {
obj.cluster =
Some(try!(ClusterDeserializer::deserialize("Cluster", stack)));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct 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(Default, Debug, Clone, PartialEq)]
pub struct ModifyClusterIamRolesResult {
pub cluster: Option<Cluster>,
}
struct ModifyClusterIamRolesResultDeserializer;
impl ModifyClusterIamRolesResultDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ModifyClusterIamRolesResult, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = ModifyClusterIamRolesResult::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"Cluster" => {
obj.cluster =
Some(try!(ClusterDeserializer::deserialize("Cluster", stack)));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct 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 enhanced_vpc_routing: Option<bool>,
pub hsm_client_certificate_identifier: Option<String>,
pub hsm_configuration_identifier: Option<String>,
pub maintenance_track_name: Option<String>,
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.to_string(),
);
}
if let Some(ref field_value) = obj.automated_snapshot_retention_period {
params.put(
&format!("{}{}", prefix, "AutomatedSnapshotRetentionPeriod"),
&field_value.to_string(),
);
}
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.enhanced_vpc_routing {
params.put(
&format!("{}{}", prefix, "EnhancedVpcRouting"),
&field_value.to_string(),
);
}
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.maintenance_track_name {
params.put(
&format!("{}{}", prefix, "MaintenanceTrackName"),
&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.to_string(),
);
}
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.to_string(),
);
}
if let Some(ref field_value) = obj.vpc_security_group_ids {
VpcSecurityGroupIdListSerializer::serialize(
params,
&format!("{}{}", prefix, "VpcSecurityGroupId"),
field_value,
);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
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(Default, Debug, Clone, PartialEq)]
pub struct ModifyClusterResult {
pub cluster: Option<Cluster>,
}
struct ModifyClusterResultDeserializer;
impl ModifyClusterResultDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ModifyClusterResult, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = ModifyClusterResult::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"Cluster" => {
obj.cluster =
Some(try!(ClusterDeserializer::deserialize("Cluster", stack)));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct 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(Default, Debug, Clone, PartialEq)]
pub struct ModifyClusterSubnetGroupResult {
pub cluster_subnet_group: Option<ClusterSubnetGroup>,
}
struct ModifyClusterSubnetGroupResultDeserializer;
impl ModifyClusterSubnetGroupResultDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ModifyClusterSubnetGroupResult, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = ModifyClusterSubnetGroupResult::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"ClusterSubnetGroup" => {
obj.cluster_subnet_group =
Some(try!(ClusterSubnetGroupDeserializer::deserialize(
"ClusterSubnetGroup",
stack
)));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct 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.to_string(),
);
}
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(Default, Debug, Clone, PartialEq)]
pub struct ModifyEventSubscriptionResult {
pub event_subscription: Option<EventSubscription>,
}
struct ModifyEventSubscriptionResultDeserializer;
impl ModifyEventSubscriptionResultDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ModifyEventSubscriptionResult, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = ModifyEventSubscriptionResult::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"EventSubscription" => {
obj.event_subscription = Some(try!(
EventSubscriptionDeserializer::deserialize("EventSubscription", stack)
));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ModifySnapshotCopyRetentionPeriodMessage {
pub cluster_identifier: String,
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,
);
params.put(
&format!("{}{}", prefix, "RetentionPeriod"),
&obj.retention_period.to_string(),
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ModifySnapshotCopyRetentionPeriodResult {
pub cluster: Option<Cluster>,
}
struct ModifySnapshotCopyRetentionPeriodResultDeserializer;
impl ModifySnapshotCopyRetentionPeriodResultDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ModifySnapshotCopyRetentionPeriodResult, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = ModifySnapshotCopyRetentionPeriodResult::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"Cluster" => {
obj.cluster =
Some(try!(ClusterDeserializer::deserialize("Cluster", stack)));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct OrderableClusterOption {
pub availability_zones: Option<Vec<AvailabilityZone>>,
pub cluster_type: Option<String>,
pub cluster_version: Option<String>,
pub node_type: Option<String>,
}
struct OrderableClusterOptionDeserializer;
impl OrderableClusterOptionDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<OrderableClusterOption, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = OrderableClusterOption::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"AvailabilityZones" => {
obj.availability_zones = match obj.availability_zones {
Some(ref mut existing) => {
existing.extend(try!(
AvailabilityZoneListDeserializer::deserialize(
"AvailabilityZones",
stack
)
));
Some(existing.to_vec())
}
None => Some(try!(AvailabilityZoneListDeserializer::deserialize(
"AvailabilityZones",
stack
))),
};
}
"ClusterType" => {
obj.cluster_type =
Some(try!(StringDeserializer::deserialize("ClusterType", stack)));
}
"ClusterVersion" => {
obj.cluster_version = Some(try!(StringDeserializer::deserialize(
"ClusterVersion",
stack
)));
}
"NodeType" => {
obj.node_type =
Some(try!(StringDeserializer::deserialize("NodeType", stack)));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
struct OrderableClusterOptionsListDeserializer;
impl OrderableClusterOptionsListDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<OrderableClusterOption>, XmlParseError> {
let mut obj = vec![];
try!(start_element(tag_name, stack));
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "OrderableClusterOption" {
obj.push(try!(OrderableClusterOptionDeserializer::deserialize(
"OrderableClusterOption",
stack
)));
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
try!(end_element(tag_name, stack));
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct OrderableClusterOptionsMessage {
pub marker: Option<String>,
pub orderable_cluster_options: Option<Vec<OrderableClusterOption>>,
}
struct OrderableClusterOptionsMessageDeserializer;
impl OrderableClusterOptionsMessageDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<OrderableClusterOptionsMessage, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = OrderableClusterOptionsMessage::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"Marker" => {
obj.marker = Some(try!(StringDeserializer::deserialize("Marker", stack)));
}
"OrderableClusterOptions" => {
obj.orderable_cluster_options = match obj.orderable_cluster_options {
Some(ref mut existing) => {
existing.extend(try!(
OrderableClusterOptionsListDeserializer::deserialize(
"OrderableClusterOptions",
stack
)
));
Some(existing.to_vec())
}
None => {
Some(try!(OrderableClusterOptionsListDeserializer::deserialize(
"OrderableClusterOptions",
stack
)))
}
};
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct 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>,
}
struct ParameterDeserializer;
impl ParameterDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Parameter, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = Parameter::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"AllowedValues" => {
obj.allowed_values = Some(try!(StringDeserializer::deserialize(
"AllowedValues",
stack
)));
}
"ApplyType" => {
obj.apply_type = Some(try!(ParameterApplyTypeDeserializer::deserialize(
"ApplyType",
stack
)));
}
"DataType" => {
obj.data_type =
Some(try!(StringDeserializer::deserialize("DataType", stack)));
}
"Description" => {
obj.description =
Some(try!(StringDeserializer::deserialize("Description", stack)));
}
"IsModifiable" => {
obj.is_modifiable = Some(try!(BooleanDeserializer::deserialize(
"IsModifiable",
stack
)));
}
"MinimumEngineVersion" => {
obj.minimum_engine_version = Some(try!(StringDeserializer::deserialize(
"MinimumEngineVersion",
stack
)));
}
"ParameterName" => {
obj.parameter_name = Some(try!(StringDeserializer::deserialize(
"ParameterName",
stack
)));
}
"ParameterValue" => {
obj.parameter_value = Some(try!(StringDeserializer::deserialize(
"ParameterValue",
stack
)));
}
"Source" => {
obj.source = Some(try!(StringDeserializer::deserialize("Source", stack)));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
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.to_string(),
);
}
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);
}
}
}
struct ParameterApplyTypeDeserializer;
impl ParameterApplyTypeDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
try!(start_element(tag_name, stack));
let obj = try!(characters(stack));
try!(end_element(tag_name, stack));
Ok(obj)
}
}
struct ParameterGroupListDeserializer;
impl ParameterGroupListDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<ClusterParameterGroup>, XmlParseError> {
let mut obj = vec![];
try!(start_element(tag_name, stack));
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "ClusterParameterGroup" {
obj.push(try!(ClusterParameterGroupDeserializer::deserialize(
"ClusterParameterGroup",
stack
)));
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
try!(end_element(tag_name, stack));
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
struct ParametersListDeserializer;
impl ParametersListDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<Parameter>, XmlParseError> {
let mut obj = vec![];
try!(start_element(tag_name, stack));
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "Parameter" {
obj.push(try!(ParameterDeserializer::deserialize("Parameter", stack)));
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
try!(end_element(tag_name, stack));
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
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);
}
}
}
struct PendingActionsListDeserializer;
impl PendingActionsListDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<String>, XmlParseError> {
let mut obj = vec![];
try!(start_element(tag_name, stack));
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "member" {
obj.push(try!(StringDeserializer::deserialize("member", stack)));
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
try!(end_element(tag_name, stack));
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct PendingModifiedValues {
pub automated_snapshot_retention_period: Option<i64>,
pub cluster_identifier: Option<String>,
pub cluster_type: Option<String>,
pub cluster_version: 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>,
}
struct PendingModifiedValuesDeserializer;
impl PendingModifiedValuesDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<PendingModifiedValues, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = PendingModifiedValues::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"AutomatedSnapshotRetentionPeriod" => {
obj.automated_snapshot_retention_period =
Some(try!(IntegerOptionalDeserializer::deserialize(
"AutomatedSnapshotRetentionPeriod",
stack
)));
}
"ClusterIdentifier" => {
obj.cluster_identifier = Some(try!(StringDeserializer::deserialize(
"ClusterIdentifier",
stack
)));
}
"ClusterType" => {
obj.cluster_type =
Some(try!(StringDeserializer::deserialize("ClusterType", stack)));
}
"ClusterVersion" => {
obj.cluster_version = Some(try!(StringDeserializer::deserialize(
"ClusterVersion",
stack
)));
}
"EnhancedVpcRouting" => {
obj.enhanced_vpc_routing = Some(try!(
BooleanOptionalDeserializer::deserialize("EnhancedVpcRouting", stack)
));
}
"MaintenanceTrackName" => {
obj.maintenance_track_name = Some(try!(StringDeserializer::deserialize(
"MaintenanceTrackName",
stack
)));
}
"MasterUserPassword" => {
obj.master_user_password = Some(try!(StringDeserializer::deserialize(
"MasterUserPassword",
stack
)));
}
"NodeType" => {
obj.node_type =
Some(try!(StringDeserializer::deserialize("NodeType", stack)));
}
"NumberOfNodes" => {
obj.number_of_nodes = Some(try!(IntegerOptionalDeserializer::deserialize(
"NumberOfNodes",
stack
)));
}
"PubliclyAccessible" => {
obj.publicly_accessible = Some(try!(
BooleanOptionalDeserializer::deserialize("PubliclyAccessible", stack)
));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct 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.to_string(),
);
}
params.put(
&format!("{}{}", prefix, "ReservedNodeOfferingId"),
&obj.reserved_node_offering_id,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct PurchaseReservedNodeOfferingResult {
pub reserved_node: Option<ReservedNode>,
}
struct PurchaseReservedNodeOfferingResultDeserializer;
impl PurchaseReservedNodeOfferingResultDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<PurchaseReservedNodeOfferingResult, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = PurchaseReservedNodeOfferingResult::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"ReservedNode" => {
obj.reserved_node = Some(try!(ReservedNodeDeserializer::deserialize(
"ReservedNode",
stack
)));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct 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(Default, Debug, Clone, PartialEq)]
pub struct RebootClusterResult {
pub cluster: Option<Cluster>,
}
struct RebootClusterResultDeserializer;
impl RebootClusterResultDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<RebootClusterResult, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = RebootClusterResult::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"Cluster" => {
obj.cluster =
Some(try!(ClusterDeserializer::deserialize("Cluster", stack)));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct RecurringCharge {
pub recurring_charge_amount: Option<f64>,
pub recurring_charge_frequency: Option<String>,
}
struct RecurringChargeDeserializer;
impl RecurringChargeDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<RecurringCharge, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = RecurringCharge::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"RecurringChargeAmount" => {
obj.recurring_charge_amount = Some(try!(DoubleDeserializer::deserialize(
"RecurringChargeAmount",
stack
)));
}
"RecurringChargeFrequency" => {
obj.recurring_charge_frequency = Some(try!(
StringDeserializer::deserialize("RecurringChargeFrequency", stack)
));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
struct RecurringChargeListDeserializer;
impl RecurringChargeListDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<RecurringCharge>, XmlParseError> {
let mut obj = vec![];
try!(start_element(tag_name, stack));
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "RecurringCharge" {
obj.push(try!(RecurringChargeDeserializer::deserialize(
"RecurringCharge",
stack
)));
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
try!(end_element(tag_name, stack));
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct 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>,
}
struct ReservedNodeDeserializer;
impl ReservedNodeDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ReservedNode, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = ReservedNode::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"CurrencyCode" => {
obj.currency_code =
Some(try!(StringDeserializer::deserialize("CurrencyCode", stack)));
}
"Duration" => {
obj.duration =
Some(try!(IntegerDeserializer::deserialize("Duration", stack)));
}
"FixedPrice" => {
obj.fixed_price =
Some(try!(DoubleDeserializer::deserialize("FixedPrice", stack)));
}
"NodeCount" => {
obj.node_count =
Some(try!(IntegerDeserializer::deserialize("NodeCount", stack)));
}
"NodeType" => {
obj.node_type =
Some(try!(StringDeserializer::deserialize("NodeType", stack)));
}
"OfferingType" => {
obj.offering_type =
Some(try!(StringDeserializer::deserialize("OfferingType", stack)));
}
"RecurringCharges" => {
obj.recurring_charges = match obj.recurring_charges {
Some(ref mut existing) => {
existing.extend(try!(
RecurringChargeListDeserializer::deserialize(
"RecurringCharges",
stack
)
));
Some(existing.to_vec())
}
None => Some(try!(RecurringChargeListDeserializer::deserialize(
"RecurringCharges",
stack
))),
};
}
"ReservedNodeId" => {
obj.reserved_node_id = Some(try!(StringDeserializer::deserialize(
"ReservedNodeId",
stack
)));
}
"ReservedNodeOfferingId" => {
obj.reserved_node_offering_id = Some(try!(
StringDeserializer::deserialize("ReservedNodeOfferingId", stack)
));
}
"ReservedNodeOfferingType" => {
obj.reserved_node_offering_type =
Some(try!(ReservedNodeOfferingTypeDeserializer::deserialize(
"ReservedNodeOfferingType",
stack
)));
}
"StartTime" => {
obj.start_time =
Some(try!(TStampDeserializer::deserialize("StartTime", stack)));
}
"State" => {
obj.state = Some(try!(StringDeserializer::deserialize("State", stack)));
}
"UsagePrice" => {
obj.usage_price =
Some(try!(DoubleDeserializer::deserialize("UsagePrice", stack)));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
struct ReservedNodeListDeserializer;
impl ReservedNodeListDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<ReservedNode>, XmlParseError> {
let mut obj = vec![];
try!(start_element(tag_name, stack));
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "ReservedNode" {
obj.push(try!(ReservedNodeDeserializer::deserialize(
"ReservedNode",
stack
)));
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
try!(end_element(tag_name, stack));
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct 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>,
}
struct ReservedNodeOfferingDeserializer;
impl ReservedNodeOfferingDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ReservedNodeOffering, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = ReservedNodeOffering::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"CurrencyCode" => {
obj.currency_code =
Some(try!(StringDeserializer::deserialize("CurrencyCode", stack)));
}
"Duration" => {
obj.duration =
Some(try!(IntegerDeserializer::deserialize("Duration", stack)));
}
"FixedPrice" => {
obj.fixed_price =
Some(try!(DoubleDeserializer::deserialize("FixedPrice", stack)));
}
"NodeType" => {
obj.node_type =
Some(try!(StringDeserializer::deserialize("NodeType", stack)));
}
"OfferingType" => {
obj.offering_type =
Some(try!(StringDeserializer::deserialize("OfferingType", stack)));
}
"RecurringCharges" => {
obj.recurring_charges = match obj.recurring_charges {
Some(ref mut existing) => {
existing.extend(try!(
RecurringChargeListDeserializer::deserialize(
"RecurringCharges",
stack
)
));
Some(existing.to_vec())
}
None => Some(try!(RecurringChargeListDeserializer::deserialize(
"RecurringCharges",
stack
))),
};
}
"ReservedNodeOfferingId" => {
obj.reserved_node_offering_id = Some(try!(
StringDeserializer::deserialize("ReservedNodeOfferingId", stack)
));
}
"ReservedNodeOfferingType" => {
obj.reserved_node_offering_type =
Some(try!(ReservedNodeOfferingTypeDeserializer::deserialize(
"ReservedNodeOfferingType",
stack
)));
}
"UsagePrice" => {
obj.usage_price =
Some(try!(DoubleDeserializer::deserialize("UsagePrice", stack)));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
struct ReservedNodeOfferingListDeserializer;
impl ReservedNodeOfferingListDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<ReservedNodeOffering>, XmlParseError> {
let mut obj = vec![];
try!(start_element(tag_name, stack));
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "ReservedNodeOffering" {
obj.push(try!(ReservedNodeOfferingDeserializer::deserialize(
"ReservedNodeOffering",
stack
)));
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
try!(end_element(tag_name, stack));
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
struct ReservedNodeOfferingTypeDeserializer;
impl ReservedNodeOfferingTypeDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
try!(start_element(tag_name, stack));
let obj = try!(characters(stack));
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ReservedNodeOfferingsMessage {
pub marker: Option<String>,
pub reserved_node_offerings: Option<Vec<ReservedNodeOffering>>,
}
struct ReservedNodeOfferingsMessageDeserializer;
impl ReservedNodeOfferingsMessageDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ReservedNodeOfferingsMessage, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = ReservedNodeOfferingsMessage::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"Marker" => {
obj.marker = Some(try!(StringDeserializer::deserialize("Marker", stack)));
}
"ReservedNodeOfferings" => {
obj.reserved_node_offerings = match obj.reserved_node_offerings {
Some(ref mut existing) => {
existing.extend(try!(
ReservedNodeOfferingListDeserializer::deserialize(
"ReservedNodeOfferings",
stack
)
));
Some(existing.to_vec())
}
None => Some(try!(ReservedNodeOfferingListDeserializer::deserialize(
"ReservedNodeOfferings",
stack
))),
};
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ReservedNodesMessage {
pub marker: Option<String>,
pub reserved_nodes: Option<Vec<ReservedNode>>,
}
struct ReservedNodesMessageDeserializer;
impl ReservedNodesMessageDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ReservedNodesMessage, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = ReservedNodesMessage::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"Marker" => {
obj.marker = Some(try!(StringDeserializer::deserialize("Marker", stack)));
}
"ReservedNodes" => {
obj.reserved_nodes = match obj.reserved_nodes {
Some(ref mut existing) => {
existing.extend(try!(ReservedNodeListDeserializer::deserialize(
"ReservedNodes",
stack
)));
Some(existing.to_vec())
}
None => Some(try!(ReservedNodeListDeserializer::deserialize(
"ReservedNodes",
stack
))),
};
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct 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.to_string(),
);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ResizeProgressMessage {
pub avg_resize_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 import_tables_completed: Option<Vec<String>>,
pub import_tables_in_progress: Option<Vec<String>>,
pub import_tables_not_started: Option<Vec<String>>,
pub progress_in_mega_bytes: Option<i64>,
pub status: Option<String>,
pub target_cluster_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>,
}
struct ResizeProgressMessageDeserializer;
impl ResizeProgressMessageDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ResizeProgressMessage, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = ResizeProgressMessage::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"AvgResizeRateInMegaBytesPerSecond" => {
obj.avg_resize_rate_in_mega_bytes_per_second =
Some(try!(DoubleOptionalDeserializer::deserialize(
"AvgResizeRateInMegaBytesPerSecond",
stack
)));
}
"ElapsedTimeInSeconds" => {
obj.elapsed_time_in_seconds = Some(try!(
LongOptionalDeserializer::deserialize("ElapsedTimeInSeconds", stack)
));
}
"EstimatedTimeToCompletionInSeconds" => {
obj.estimated_time_to_completion_in_seconds =
Some(try!(LongOptionalDeserializer::deserialize(
"EstimatedTimeToCompletionInSeconds",
stack
)));
}
"ImportTablesCompleted" => {
obj.import_tables_completed = match obj.import_tables_completed {
Some(ref mut existing) => {
existing.extend(try!(
ImportTablesCompletedDeserializer::deserialize(
"ImportTablesCompleted",
stack
)
));
Some(existing.to_vec())
}
None => Some(try!(ImportTablesCompletedDeserializer::deserialize(
"ImportTablesCompleted",
stack
))),
};
}
"ImportTablesInProgress" => {
obj.import_tables_in_progress = match obj.import_tables_in_progress {
Some(ref mut existing) => {
existing.extend(try!(
ImportTablesInProgressDeserializer::deserialize(
"ImportTablesInProgress",
stack
)
));
Some(existing.to_vec())
}
None => Some(try!(ImportTablesInProgressDeserializer::deserialize(
"ImportTablesInProgress",
stack
))),
};
}
"ImportTablesNotStarted" => {
obj.import_tables_not_started = match obj.import_tables_not_started {
Some(ref mut existing) => {
existing.extend(try!(
ImportTablesNotStartedDeserializer::deserialize(
"ImportTablesNotStarted",
stack
)
));
Some(existing.to_vec())
}
None => Some(try!(ImportTablesNotStartedDeserializer::deserialize(
"ImportTablesNotStarted",
stack
))),
};
}
"ProgressInMegaBytes" => {
obj.progress_in_mega_bytes = Some(try!(
LongOptionalDeserializer::deserialize("ProgressInMegaBytes", stack)
));
}
"Status" => {
obj.status = Some(try!(StringDeserializer::deserialize("Status", stack)));
}
"TargetClusterType" => {
obj.target_cluster_type = Some(try!(StringDeserializer::deserialize(
"TargetClusterType",
stack
)));
}
"TargetNodeType" => {
obj.target_node_type = Some(try!(StringDeserializer::deserialize(
"TargetNodeType",
stack
)));
}
"TargetNumberOfNodes" => {
obj.target_number_of_nodes = Some(try!(
IntegerOptionalDeserializer::deserialize("TargetNumberOfNodes", stack)
));
}
"TotalResizeDataInMegaBytes" => {
obj.total_resize_data_in_mega_bytes =
Some(try!(LongOptionalDeserializer::deserialize(
"TotalResizeDataInMegaBytes",
stack
)));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
struct RestorableNodeTypeListDeserializer;
impl RestorableNodeTypeListDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<String>, XmlParseError> {
let mut obj = vec![];
try!(start_element(tag_name, stack));
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "NodeType" {
obj.push(try!(StringDeserializer::deserialize("NodeType", stack)));
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
try!(end_element(tag_name, stack));
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct 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 node_type: Option<String>,
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 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.to_string(),
);
}
if let Some(ref field_value) = obj.automated_snapshot_retention_period {
params.put(
&format!("{}{}", prefix, "AutomatedSnapshotRetentionPeriod"),
&field_value.to_string(),
);
}
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.to_string(),
);
}
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.node_type {
params.put(&format!("{}{}", prefix, "NodeType"), &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.to_string());
}
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.to_string(),
);
}
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.vpc_security_group_ids {
VpcSecurityGroupIdListSerializer::serialize(
params,
&format!("{}{}", prefix, "VpcSecurityGroupId"),
field_value,
);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct RestoreFromClusterSnapshotResult {
pub cluster: Option<Cluster>,
}
struct RestoreFromClusterSnapshotResultDeserializer;
impl RestoreFromClusterSnapshotResultDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<RestoreFromClusterSnapshotResult, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = RestoreFromClusterSnapshotResult::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"Cluster" => {
obj.cluster =
Some(try!(ClusterDeserializer::deserialize("Cluster", stack)));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct 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>,
}
struct RestoreStatusDeserializer;
impl RestoreStatusDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<RestoreStatus, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = RestoreStatus::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"CurrentRestoreRateInMegaBytesPerSecond" => {
obj.current_restore_rate_in_mega_bytes_per_second =
Some(try!(DoubleDeserializer::deserialize(
"CurrentRestoreRateInMegaBytesPerSecond",
stack
)));
}
"ElapsedTimeInSeconds" => {
obj.elapsed_time_in_seconds = Some(try!(LongDeserializer::deserialize(
"ElapsedTimeInSeconds",
stack
)));
}
"EstimatedTimeToCompletionInSeconds" => {
obj.estimated_time_to_completion_in_seconds =
Some(try!(LongDeserializer::deserialize(
"EstimatedTimeToCompletionInSeconds",
stack
)));
}
"ProgressInMegaBytes" => {
obj.progress_in_mega_bytes = Some(try!(LongDeserializer::deserialize(
"ProgressInMegaBytes",
stack
)));
}
"SnapshotSizeInMegaBytes" => {
obj.snapshot_size_in_mega_bytes = Some(try!(
LongDeserializer::deserialize("SnapshotSizeInMegaBytes", stack)
));
}
"Status" => {
obj.status = Some(try!(StringDeserializer::deserialize("Status", stack)));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct 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(Default, Debug, Clone, PartialEq)]
pub struct RestoreTableFromClusterSnapshotResult {
pub table_restore_status: Option<TableRestoreStatus>,
}
struct RestoreTableFromClusterSnapshotResultDeserializer;
impl RestoreTableFromClusterSnapshotResultDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<RestoreTableFromClusterSnapshotResult, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = RestoreTableFromClusterSnapshotResult::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"TableRestoreStatus" => {
obj.table_restore_status =
Some(try!(TableRestoreStatusDeserializer::deserialize(
"TableRestoreStatus",
stack
)));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct RevisionTarget {
pub database_revision: Option<String>,
pub database_revision_release_date: Option<String>,
pub description: Option<String>,
}
struct RevisionTargetDeserializer;
impl RevisionTargetDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<RevisionTarget, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = RevisionTarget::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"DatabaseRevision" => {
obj.database_revision = Some(try!(StringDeserializer::deserialize(
"DatabaseRevision",
stack
)));
}
"DatabaseRevisionReleaseDate" => {
obj.database_revision_release_date = Some(try!(
TStampDeserializer::deserialize("DatabaseRevisionReleaseDate", stack)
));
}
"Description" => {
obj.description =
Some(try!(StringDeserializer::deserialize("Description", stack)));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
struct RevisionTargetsListDeserializer;
impl RevisionTargetsListDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<RevisionTarget>, XmlParseError> {
let mut obj = vec![];
try!(start_element(tag_name, stack));
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "RevisionTarget" {
obj.push(try!(RevisionTargetDeserializer::deserialize(
"RevisionTarget",
stack
)));
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
try!(end_element(tag_name, stack));
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct 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(Default, Debug, Clone, PartialEq)]
pub struct RevokeClusterSecurityGroupIngressResult {
pub cluster_security_group: Option<ClusterSecurityGroup>,
}
struct RevokeClusterSecurityGroupIngressResultDeserializer;
impl RevokeClusterSecurityGroupIngressResultDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<RevokeClusterSecurityGroupIngressResult, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = RevokeClusterSecurityGroupIngressResult::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"ClusterSecurityGroup" => {
obj.cluster_security_group =
Some(try!(ClusterSecurityGroupDeserializer::deserialize(
"ClusterSecurityGroup",
stack
)));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct 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(Default, Debug, Clone, PartialEq)]
pub struct RevokeSnapshotAccessResult {
pub snapshot: Option<Snapshot>,
}
struct RevokeSnapshotAccessResultDeserializer;
impl RevokeSnapshotAccessResultDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<RevokeSnapshotAccessResult, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = RevokeSnapshotAccessResult::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"Snapshot" => {
obj.snapshot =
Some(try!(SnapshotDeserializer::deserialize("Snapshot", stack)));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct 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(Default, Debug, Clone, PartialEq)]
pub struct RotateEncryptionKeyResult {
pub cluster: Option<Cluster>,
}
struct RotateEncryptionKeyResultDeserializer;
impl RotateEncryptionKeyResultDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<RotateEncryptionKeyResult, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = RotateEncryptionKeyResult::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"Cluster" => {
obj.cluster =
Some(try!(ClusterDeserializer::deserialize("Cluster", stack)));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
struct SensitiveStringDeserializer;
impl SensitiveStringDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
try!(start_element(tag_name, stack));
let obj = try!(characters(stack));
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct 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 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_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>,
}
struct SnapshotDeserializer;
impl SnapshotDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Snapshot, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = Snapshot::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"AccountsWithRestoreAccess" => {
obj.accounts_with_restore_access = match obj.accounts_with_restore_access {
Some(ref mut existing) => {
existing.extend(try!(
AccountsWithRestoreAccessListDeserializer::deserialize(
"AccountsWithRestoreAccess",
stack
)
));
Some(existing.to_vec())
}
None => Some(try!(
AccountsWithRestoreAccessListDeserializer::deserialize(
"AccountsWithRestoreAccess",
stack
)
)),
};
}
"ActualIncrementalBackupSizeInMegaBytes" => {
obj.actual_incremental_backup_size_in_mega_bytes =
Some(try!(DoubleDeserializer::deserialize(
"ActualIncrementalBackupSizeInMegaBytes",
stack
)));
}
"AvailabilityZone" => {
obj.availability_zone = Some(try!(StringDeserializer::deserialize(
"AvailabilityZone",
stack
)));
}
"BackupProgressInMegaBytes" => {
obj.backup_progress_in_mega_bytes = Some(try!(
DoubleDeserializer::deserialize("BackupProgressInMegaBytes", stack)
));
}
"ClusterCreateTime" => {
obj.cluster_create_time = Some(try!(TStampDeserializer::deserialize(
"ClusterCreateTime",
stack
)));
}
"ClusterIdentifier" => {
obj.cluster_identifier = Some(try!(StringDeserializer::deserialize(
"ClusterIdentifier",
stack
)));
}
"ClusterVersion" => {
obj.cluster_version = Some(try!(StringDeserializer::deserialize(
"ClusterVersion",
stack
)));
}
"CurrentBackupRateInMegaBytesPerSecond" => {
obj.current_backup_rate_in_mega_bytes_per_second =
Some(try!(DoubleDeserializer::deserialize(
"CurrentBackupRateInMegaBytesPerSecond",
stack
)));
}
"DBName" => {
obj.db_name = Some(try!(StringDeserializer::deserialize("DBName", stack)));
}
"ElapsedTimeInSeconds" => {
obj.elapsed_time_in_seconds = Some(try!(LongDeserializer::deserialize(
"ElapsedTimeInSeconds",
stack
)));
}
"Encrypted" => {
obj.encrypted =
Some(try!(BooleanDeserializer::deserialize("Encrypted", stack)));
}
"EncryptedWithHSM" => {
obj.encrypted_with_hsm = Some(try!(BooleanDeserializer::deserialize(
"EncryptedWithHSM",
stack
)));
}
"EnhancedVpcRouting" => {
obj.enhanced_vpc_routing = Some(try!(BooleanDeserializer::deserialize(
"EnhancedVpcRouting",
stack
)));
}
"EstimatedSecondsToCompletion" => {
obj.estimated_seconds_to_completion = Some(try!(
LongDeserializer::deserialize("EstimatedSecondsToCompletion", stack)
));
}
"KmsKeyId" => {
obj.kms_key_id =
Some(try!(StringDeserializer::deserialize("KmsKeyId", stack)));
}
"MaintenanceTrackName" => {
obj.maintenance_track_name = Some(try!(StringDeserializer::deserialize(
"MaintenanceTrackName",
stack
)));
}
"MasterUsername" => {
obj.master_username = Some(try!(StringDeserializer::deserialize(
"MasterUsername",
stack
)));
}
"NodeType" => {
obj.node_type =
Some(try!(StringDeserializer::deserialize("NodeType", stack)));
}
"NumberOfNodes" => {
obj.number_of_nodes = Some(try!(IntegerDeserializer::deserialize(
"NumberOfNodes",
stack
)));
}
"OwnerAccount" => {
obj.owner_account =
Some(try!(StringDeserializer::deserialize("OwnerAccount", stack)));
}
"Port" => {
obj.port = Some(try!(IntegerDeserializer::deserialize("Port", stack)));
}
"RestorableNodeTypes" => {
obj.restorable_node_types = match obj.restorable_node_types {
Some(ref mut existing) => {
existing.extend(try!(
RestorableNodeTypeListDeserializer::deserialize(
"RestorableNodeTypes",
stack
)
));
Some(existing.to_vec())
}
None => Some(try!(RestorableNodeTypeListDeserializer::deserialize(
"RestorableNodeTypes",
stack
))),
};
}
"SnapshotCreateTime" => {
obj.snapshot_create_time = Some(try!(TStampDeserializer::deserialize(
"SnapshotCreateTime",
stack
)));
}
"SnapshotIdentifier" => {
obj.snapshot_identifier = Some(try!(StringDeserializer::deserialize(
"SnapshotIdentifier",
stack
)));
}
"SnapshotType" => {
obj.snapshot_type =
Some(try!(StringDeserializer::deserialize("SnapshotType", stack)));
}
"SourceRegion" => {
obj.source_region =
Some(try!(StringDeserializer::deserialize("SourceRegion", stack)));
}
"Status" => {
obj.status = Some(try!(StringDeserializer::deserialize("Status", stack)));
}
"Tags" => {
obj.tags = match obj.tags {
Some(ref mut existing) => {
existing
.extend(try!(TagListDeserializer::deserialize("Tags", stack)));
Some(existing.to_vec())
}
None => Some(try!(TagListDeserializer::deserialize("Tags", stack))),
};
}
"TotalBackupSizeInMegaBytes" => {
obj.total_backup_size_in_mega_bytes = Some(try!(
DoubleDeserializer::deserialize("TotalBackupSizeInMegaBytes", stack)
));
}
"VpcId" => {
obj.vpc_id = Some(try!(StringDeserializer::deserialize("VpcId", stack)));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct SnapshotCopyGrant {
pub kms_key_id: Option<String>,
pub snapshot_copy_grant_name: Option<String>,
pub tags: Option<Vec<Tag>>,
}
struct SnapshotCopyGrantDeserializer;
impl SnapshotCopyGrantDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<SnapshotCopyGrant, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = SnapshotCopyGrant::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"KmsKeyId" => {
obj.kms_key_id =
Some(try!(StringDeserializer::deserialize("KmsKeyId", stack)));
}
"SnapshotCopyGrantName" => {
obj.snapshot_copy_grant_name = Some(try!(StringDeserializer::deserialize(
"SnapshotCopyGrantName",
stack
)));
}
"Tags" => {
obj.tags = match obj.tags {
Some(ref mut existing) => {
existing
.extend(try!(TagListDeserializer::deserialize("Tags", stack)));
Some(existing.to_vec())
}
None => Some(try!(TagListDeserializer::deserialize("Tags", stack))),
};
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
struct SnapshotCopyGrantListDeserializer;
impl SnapshotCopyGrantListDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<SnapshotCopyGrant>, XmlParseError> {
let mut obj = vec![];
try!(start_element(tag_name, stack));
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "SnapshotCopyGrant" {
obj.push(try!(SnapshotCopyGrantDeserializer::deserialize(
"SnapshotCopyGrant",
stack
)));
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
try!(end_element(tag_name, stack));
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct SnapshotCopyGrantMessage {
pub marker: Option<String>,
pub snapshot_copy_grants: Option<Vec<SnapshotCopyGrant>>,
}
struct SnapshotCopyGrantMessageDeserializer;
impl SnapshotCopyGrantMessageDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<SnapshotCopyGrantMessage, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = SnapshotCopyGrantMessage::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"Marker" => {
obj.marker = Some(try!(StringDeserializer::deserialize("Marker", stack)));
}
"SnapshotCopyGrants" => {
obj.snapshot_copy_grants = match obj.snapshot_copy_grants {
Some(ref mut existing) => {
existing.extend(try!(
SnapshotCopyGrantListDeserializer::deserialize(
"SnapshotCopyGrants",
stack
)
));
Some(existing.to_vec())
}
None => Some(try!(SnapshotCopyGrantListDeserializer::deserialize(
"SnapshotCopyGrants",
stack
))),
};
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
struct SnapshotListDeserializer;
impl SnapshotListDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<Snapshot>, XmlParseError> {
let mut obj = vec![];
try!(start_element(tag_name, stack));
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "Snapshot" {
obj.push(try!(SnapshotDeserializer::deserialize("Snapshot", stack)));
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
try!(end_element(tag_name, stack));
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct SnapshotMessage {
pub marker: Option<String>,
pub snapshots: Option<Vec<Snapshot>>,
}
struct SnapshotMessageDeserializer;
impl SnapshotMessageDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<SnapshotMessage, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = SnapshotMessage::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"Marker" => {
obj.marker = Some(try!(StringDeserializer::deserialize("Marker", stack)));
}
"Snapshots" => {
obj.snapshots = match obj.snapshots {
Some(ref mut existing) => {
existing.extend(try!(SnapshotListDeserializer::deserialize(
"Snapshots",
stack
)));
Some(existing.to_vec())
}
None => Some(try!(SnapshotListDeserializer::deserialize(
"Snapshots",
stack
))),
};
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
struct SourceIdsListDeserializer;
impl SourceIdsListDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<String>, XmlParseError> {
let mut obj = vec![];
try!(start_element(tag_name, stack));
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "SourceId" {
obj.push(try!(StringDeserializer::deserialize("SourceId", stack)));
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
try!(end_element(tag_name, stack));
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
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);
}
}
}
struct SourceTypeDeserializer;
impl SourceTypeDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
try!(start_element(tag_name, stack));
let obj = try!(characters(stack));
try!(end_element(tag_name, stack));
Ok(obj)
}
}
struct StringDeserializer;
impl StringDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
try!(start_element(tag_name, stack));
let obj = try!(characters(stack));
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct Subnet {
pub subnet_availability_zone: Option<AvailabilityZone>,
pub subnet_identifier: Option<String>,
pub subnet_status: Option<String>,
}
struct SubnetDeserializer;
impl SubnetDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Subnet, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = Subnet::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"SubnetAvailabilityZone" => {
obj.subnet_availability_zone =
Some(try!(AvailabilityZoneDeserializer::deserialize(
"SubnetAvailabilityZone",
stack
)));
}
"SubnetIdentifier" => {
obj.subnet_identifier = Some(try!(StringDeserializer::deserialize(
"SubnetIdentifier",
stack
)));
}
"SubnetStatus" => {
obj.subnet_status =
Some(try!(StringDeserializer::deserialize("SubnetStatus", stack)));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
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);
}
}
}
struct SubnetListDeserializer;
impl SubnetListDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<Subnet>, XmlParseError> {
let mut obj = vec![];
try!(start_element(tag_name, stack));
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "Subnet" {
obj.push(try!(SubnetDeserializer::deserialize("Subnet", stack)));
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
try!(end_element(tag_name, stack));
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct SupportedPlatform {
pub name: Option<String>,
}
struct SupportedPlatformDeserializer;
impl SupportedPlatformDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<SupportedPlatform, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = SupportedPlatform::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"Name" => {
obj.name = Some(try!(StringDeserializer::deserialize("Name", stack)));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
struct SupportedPlatformsListDeserializer;
impl SupportedPlatformsListDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<SupportedPlatform>, XmlParseError> {
let mut obj = vec![];
try!(start_element(tag_name, stack));
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "SupportedPlatform" {
obj.push(try!(SupportedPlatformDeserializer::deserialize(
"SupportedPlatform",
stack
)));
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
try!(end_element(tag_name, stack));
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
struct TStampDeserializer;
impl TStampDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
try!(start_element(tag_name, stack));
let obj = try!(characters(stack));
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct 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>,
}
struct TableRestoreStatusDeserializer;
impl TableRestoreStatusDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<TableRestoreStatus, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = TableRestoreStatus::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"ClusterIdentifier" => {
obj.cluster_identifier = Some(try!(StringDeserializer::deserialize(
"ClusterIdentifier",
stack
)));
}
"Message" => {
obj.message = Some(try!(StringDeserializer::deserialize("Message", stack)));
}
"NewTableName" => {
obj.new_table_name =
Some(try!(StringDeserializer::deserialize("NewTableName", stack)));
}
"ProgressInMegaBytes" => {
obj.progress_in_mega_bytes = Some(try!(
LongOptionalDeserializer::deserialize("ProgressInMegaBytes", stack)
));
}
"RequestTime" => {
obj.request_time =
Some(try!(TStampDeserializer::deserialize("RequestTime", stack)));
}
"SnapshotIdentifier" => {
obj.snapshot_identifier = Some(try!(StringDeserializer::deserialize(
"SnapshotIdentifier",
stack
)));
}
"SourceDatabaseName" => {
obj.source_database_name = Some(try!(StringDeserializer::deserialize(
"SourceDatabaseName",
stack
)));
}
"SourceSchemaName" => {
obj.source_schema_name = Some(try!(StringDeserializer::deserialize(
"SourceSchemaName",
stack
)));
}
"SourceTableName" => {
obj.source_table_name = Some(try!(StringDeserializer::deserialize(
"SourceTableName",
stack
)));
}
"Status" => {
obj.status = Some(try!(TableRestoreStatusTypeDeserializer::deserialize(
"Status", stack
)));
}
"TableRestoreRequestId" => {
obj.table_restore_request_id = Some(try!(StringDeserializer::deserialize(
"TableRestoreRequestId",
stack
)));
}
"TargetDatabaseName" => {
obj.target_database_name = Some(try!(StringDeserializer::deserialize(
"TargetDatabaseName",
stack
)));
}
"TargetSchemaName" => {
obj.target_schema_name = Some(try!(StringDeserializer::deserialize(
"TargetSchemaName",
stack
)));
}
"TotalDataInMegaBytes" => {
obj.total_data_in_mega_bytes = Some(try!(
LongOptionalDeserializer::deserialize("TotalDataInMegaBytes", stack)
));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
struct TableRestoreStatusListDeserializer;
impl TableRestoreStatusListDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<TableRestoreStatus>, XmlParseError> {
let mut obj = vec![];
try!(start_element(tag_name, stack));
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "TableRestoreStatus" {
obj.push(try!(TableRestoreStatusDeserializer::deserialize(
"TableRestoreStatus",
stack
)));
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
try!(end_element(tag_name, stack));
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct TableRestoreStatusMessage {
pub marker: Option<String>,
pub table_restore_status_details: Option<Vec<TableRestoreStatus>>,
}
struct TableRestoreStatusMessageDeserializer;
impl TableRestoreStatusMessageDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<TableRestoreStatusMessage, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = TableRestoreStatusMessage::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"Marker" => {
obj.marker = Some(try!(StringDeserializer::deserialize("Marker", stack)));
}
"TableRestoreStatusDetails" => {
obj.table_restore_status_details = match obj.table_restore_status_details {
Some(ref mut existing) => {
existing.extend(try!(
TableRestoreStatusListDeserializer::deserialize(
"TableRestoreStatusDetails",
stack
)
));
Some(existing.to_vec())
}
None => Some(try!(TableRestoreStatusListDeserializer::deserialize(
"TableRestoreStatusDetails",
stack
))),
};
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
struct TableRestoreStatusTypeDeserializer;
impl TableRestoreStatusTypeDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
try!(start_element(tag_name, stack));
let obj = try!(characters(stack));
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct Tag {
pub key: Option<String>,
pub value: Option<String>,
}
struct TagDeserializer;
impl TagDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Tag, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = Tag::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"Key" => {
obj.key = Some(try!(StringDeserializer::deserialize("Key", stack)));
}
"Value" => {
obj.value = Some(try!(StringDeserializer::deserialize("Value", stack)));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
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);
}
}
}
struct TagListDeserializer;
impl TagListDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<Tag>, XmlParseError> {
let mut obj = vec![];
try!(start_element(tag_name, stack));
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "Tag" {
obj.push(try!(TagDeserializer::deserialize("Tag", stack)));
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
try!(end_element(tag_name, stack));
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
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(Default, Debug, Clone, PartialEq)]
pub struct TaggedResource {
pub resource_name: Option<String>,
pub resource_type: Option<String>,
pub tag: Option<Tag>,
}
struct TaggedResourceDeserializer;
impl TaggedResourceDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<TaggedResource, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = TaggedResource::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"ResourceName" => {
obj.resource_name =
Some(try!(StringDeserializer::deserialize("ResourceName", stack)));
}
"ResourceType" => {
obj.resource_type =
Some(try!(StringDeserializer::deserialize("ResourceType", stack)));
}
"Tag" => {
obj.tag = Some(try!(TagDeserializer::deserialize("Tag", stack)));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
struct TaggedResourceListDeserializer;
impl TaggedResourceListDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<TaggedResource>, XmlParseError> {
let mut obj = vec![];
try!(start_element(tag_name, stack));
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "TaggedResource" {
obj.push(try!(TaggedResourceDeserializer::deserialize(
"TaggedResource",
stack
)));
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
try!(end_element(tag_name, stack));
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct TaggedResourceListMessage {
pub marker: Option<String>,
pub tagged_resources: Option<Vec<TaggedResource>>,
}
struct TaggedResourceListMessageDeserializer;
impl TaggedResourceListMessageDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<TaggedResourceListMessage, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = TaggedResourceListMessage::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"Marker" => {
obj.marker = Some(try!(StringDeserializer::deserialize("Marker", stack)));
}
"TaggedResources" => {
obj.tagged_resources = match obj.tagged_resources {
Some(ref mut existing) => {
existing.extend(try!(TaggedResourceListDeserializer::deserialize(
"TaggedResources",
stack
)));
Some(existing.to_vec())
}
None => Some(try!(TaggedResourceListDeserializer::deserialize(
"TaggedResources",
stack
))),
};
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
struct TrackListDeserializer;
impl TrackListDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<MaintenanceTrack>, XmlParseError> {
let mut obj = vec![];
try!(start_element(tag_name, stack));
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "MaintenanceTrack" {
obj.push(try!(MaintenanceTrackDeserializer::deserialize(
"MaintenanceTrack",
stack
)));
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
try!(end_element(tag_name, stack));
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct TrackListMessage {
pub maintenance_tracks: Option<Vec<MaintenanceTrack>>,
pub marker: Option<String>,
}
struct TrackListMessageDeserializer;
impl TrackListMessageDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<TrackListMessage, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = TrackListMessage::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"MaintenanceTracks" => {
obj.maintenance_tracks = match obj.maintenance_tracks {
Some(ref mut existing) => {
existing.extend(try!(TrackListDeserializer::deserialize(
"MaintenanceTracks",
stack
)));
Some(existing.to_vec())
}
None => Some(try!(TrackListDeserializer::deserialize(
"MaintenanceTracks",
stack
))),
};
}
"Marker" => {
obj.marker = Some(try!(StringDeserializer::deserialize("Marker", stack)));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct UpdateTarget {
pub database_version: Option<String>,
pub maintenance_track_name: Option<String>,
}
struct UpdateTargetDeserializer;
impl UpdateTargetDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<UpdateTarget, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = UpdateTarget::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"DatabaseVersion" => {
obj.database_version = Some(try!(StringDeserializer::deserialize(
"DatabaseVersion",
stack
)));
}
"MaintenanceTrackName" => {
obj.maintenance_track_name = Some(try!(StringDeserializer::deserialize(
"MaintenanceTrackName",
stack
)));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(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(Default, Debug, Clone, PartialEq)]
pub struct VpcSecurityGroupMembership {
pub status: Option<String>,
pub vpc_security_group_id: Option<String>,
}
struct VpcSecurityGroupMembershipDeserializer;
impl VpcSecurityGroupMembershipDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<VpcSecurityGroupMembership, XmlParseError> {
try!(start_element(tag_name, stack));
let mut obj = VpcSecurityGroupMembership::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"Status" => {
obj.status = Some(try!(StringDeserializer::deserialize("Status", stack)));
}
"VpcSecurityGroupId" => {
obj.vpc_security_group_id = Some(try!(StringDeserializer::deserialize(
"VpcSecurityGroupId",
stack
)));
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
try!(end_element(tag_name, stack));
Ok(obj)
}
}
struct VpcSecurityGroupMembershipListDeserializer;
impl VpcSecurityGroupMembershipListDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<VpcSecurityGroupMembership>, XmlParseError> {
let mut obj = vec![];
try!(start_element(tag_name, stack));
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "VpcSecurityGroup" {
obj.push(try!(VpcSecurityGroupMembershipDeserializer::deserialize(
"VpcSecurityGroup",
stack
)));
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
try!(end_element(tag_name, stack));
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
#[derive(Debug, PartialEq)]
pub enum AcceptReservedNodeExchangeError {
DependentServiceUnavailableFault(String),
InvalidReservedNodeStateFault(String),
ReservedNodeAlreadyExistsFault(String),
ReservedNodeAlreadyMigratedFault(String),
ReservedNodeNotFoundFault(String),
ReservedNodeOfferingNotFoundFault(String),
UnsupportedOperationFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl AcceptReservedNodeExchangeError {
pub fn from_response(res: BufferedHttpResponse) -> AcceptReservedNodeExchangeError {
{
let reader = EventReader::new(res.body.as_slice());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"DependentServiceUnavailableFault" => {
return AcceptReservedNodeExchangeError::DependentServiceUnavailableFault(
String::from(parsed_error.message),
)
}
"InvalidReservedNodeState" => {
return AcceptReservedNodeExchangeError::InvalidReservedNodeStateFault(
String::from(parsed_error.message),
)
}
"ReservedNodeAlreadyExists" => {
return AcceptReservedNodeExchangeError::ReservedNodeAlreadyExistsFault(
String::from(parsed_error.message),
)
}
"ReservedNodeAlreadyMigrated" => {
return AcceptReservedNodeExchangeError::ReservedNodeAlreadyMigratedFault(
String::from(parsed_error.message),
)
}
"ReservedNodeNotFound" => {
return AcceptReservedNodeExchangeError::ReservedNodeNotFoundFault(
String::from(parsed_error.message),
)
}
"ReservedNodeOfferingNotFound" => {
return AcceptReservedNodeExchangeError::ReservedNodeOfferingNotFoundFault(
String::from(parsed_error.message),
)
}
"UnsupportedOperation" => {
return AcceptReservedNodeExchangeError::UnsupportedOperationFault(
String::from(parsed_error.message),
)
}
_ => {}
}
}
}
AcceptReservedNodeExchangeError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for AcceptReservedNodeExchangeError {
fn from(err: XmlParseError) -> AcceptReservedNodeExchangeError {
let XmlParseError(message) = err;
AcceptReservedNodeExchangeError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for AcceptReservedNodeExchangeError {
fn from(err: CredentialsError) -> AcceptReservedNodeExchangeError {
AcceptReservedNodeExchangeError::Credentials(err)
}
}
impl From<HttpDispatchError> for AcceptReservedNodeExchangeError {
fn from(err: HttpDispatchError) -> AcceptReservedNodeExchangeError {
AcceptReservedNodeExchangeError::HttpDispatch(err)
}
}
impl From<io::Error> for AcceptReservedNodeExchangeError {
fn from(err: io::Error) -> AcceptReservedNodeExchangeError {
AcceptReservedNodeExchangeError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for AcceptReservedNodeExchangeError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for AcceptReservedNodeExchangeError {
fn description(&self) -> &str {
match *self {
AcceptReservedNodeExchangeError::DependentServiceUnavailableFault(ref cause) => cause,
AcceptReservedNodeExchangeError::InvalidReservedNodeStateFault(ref cause) => cause,
AcceptReservedNodeExchangeError::ReservedNodeAlreadyExistsFault(ref cause) => cause,
AcceptReservedNodeExchangeError::ReservedNodeAlreadyMigratedFault(ref cause) => cause,
AcceptReservedNodeExchangeError::ReservedNodeNotFoundFault(ref cause) => cause,
AcceptReservedNodeExchangeError::ReservedNodeOfferingNotFoundFault(ref cause) => cause,
AcceptReservedNodeExchangeError::UnsupportedOperationFault(ref cause) => cause,
AcceptReservedNodeExchangeError::Validation(ref cause) => cause,
AcceptReservedNodeExchangeError::Credentials(ref err) => err.description(),
AcceptReservedNodeExchangeError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
AcceptReservedNodeExchangeError::ParseError(ref cause) => cause,
AcceptReservedNodeExchangeError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum AuthorizeClusterSecurityGroupIngressError {
AuthorizationAlreadyExistsFault(String),
AuthorizationQuotaExceededFault(String),
ClusterSecurityGroupNotFoundFault(String),
InvalidClusterSecurityGroupStateFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl AuthorizeClusterSecurityGroupIngressError {
pub fn from_response(res: BufferedHttpResponse) -> AuthorizeClusterSecurityGroupIngressError {
{
let reader = EventReader::new(res.body.as_slice());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"AuthorizationAlreadyExists" => return AuthorizeClusterSecurityGroupIngressError::AuthorizationAlreadyExistsFault(String::from(parsed_error.message)),"AuthorizationQuotaExceeded" => return AuthorizeClusterSecurityGroupIngressError::AuthorizationQuotaExceededFault(String::from(parsed_error.message)),"ClusterSecurityGroupNotFound" => return AuthorizeClusterSecurityGroupIngressError::ClusterSecurityGroupNotFoundFault(String::from(parsed_error.message)),"InvalidClusterSecurityGroupState" => return AuthorizeClusterSecurityGroupIngressError::InvalidClusterSecurityGroupStateFault(String::from(parsed_error.message)),_ => {}
}
}
}
AuthorizeClusterSecurityGroupIngressError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for AuthorizeClusterSecurityGroupIngressError {
fn from(err: XmlParseError) -> AuthorizeClusterSecurityGroupIngressError {
let XmlParseError(message) = err;
AuthorizeClusterSecurityGroupIngressError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for AuthorizeClusterSecurityGroupIngressError {
fn from(err: CredentialsError) -> AuthorizeClusterSecurityGroupIngressError {
AuthorizeClusterSecurityGroupIngressError::Credentials(err)
}
}
impl From<HttpDispatchError> for AuthorizeClusterSecurityGroupIngressError {
fn from(err: HttpDispatchError) -> AuthorizeClusterSecurityGroupIngressError {
AuthorizeClusterSecurityGroupIngressError::HttpDispatch(err)
}
}
impl From<io::Error> for AuthorizeClusterSecurityGroupIngressError {
fn from(err: io::Error) -> AuthorizeClusterSecurityGroupIngressError {
AuthorizeClusterSecurityGroupIngressError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for AuthorizeClusterSecurityGroupIngressError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for AuthorizeClusterSecurityGroupIngressError {
fn description(&self) -> &str {
match *self {
AuthorizeClusterSecurityGroupIngressError::AuthorizationAlreadyExistsFault(
ref cause,
) => cause,
AuthorizeClusterSecurityGroupIngressError::AuthorizationQuotaExceededFault(
ref cause,
) => cause,
AuthorizeClusterSecurityGroupIngressError::ClusterSecurityGroupNotFoundFault(
ref cause,
) => cause,
AuthorizeClusterSecurityGroupIngressError::InvalidClusterSecurityGroupStateFault(
ref cause,
) => cause,
AuthorizeClusterSecurityGroupIngressError::Validation(ref cause) => cause,
AuthorizeClusterSecurityGroupIngressError::Credentials(ref err) => err.description(),
AuthorizeClusterSecurityGroupIngressError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
AuthorizeClusterSecurityGroupIngressError::ParseError(ref cause) => cause,
AuthorizeClusterSecurityGroupIngressError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum AuthorizeSnapshotAccessError {
AuthorizationAlreadyExistsFault(String),
AuthorizationQuotaExceededFault(String),
ClusterSnapshotNotFoundFault(String),
DependentServiceRequestThrottlingFault(String),
InvalidClusterSnapshotStateFault(String),
LimitExceededFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl AuthorizeSnapshotAccessError {
pub fn from_response(res: BufferedHttpResponse) -> AuthorizeSnapshotAccessError {
{
let reader = EventReader::new(res.body.as_slice());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"AuthorizationAlreadyExists" => {
return AuthorizeSnapshotAccessError::AuthorizationAlreadyExistsFault(
String::from(parsed_error.message),
)
}
"AuthorizationQuotaExceeded" => {
return AuthorizeSnapshotAccessError::AuthorizationQuotaExceededFault(
String::from(parsed_error.message),
)
}
"ClusterSnapshotNotFound" => {
return AuthorizeSnapshotAccessError::ClusterSnapshotNotFoundFault(
String::from(parsed_error.message),
)
}
"DependentServiceRequestThrottlingFault" => {
return AuthorizeSnapshotAccessError::DependentServiceRequestThrottlingFault(
String::from(parsed_error.message),
)
}
"InvalidClusterSnapshotState" => {
return AuthorizeSnapshotAccessError::InvalidClusterSnapshotStateFault(
String::from(parsed_error.message),
)
}
"LimitExceededFault" => {
return AuthorizeSnapshotAccessError::LimitExceededFault(String::from(
parsed_error.message,
))
}
_ => {}
}
}
}
AuthorizeSnapshotAccessError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for AuthorizeSnapshotAccessError {
fn from(err: XmlParseError) -> AuthorizeSnapshotAccessError {
let XmlParseError(message) = err;
AuthorizeSnapshotAccessError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for AuthorizeSnapshotAccessError {
fn from(err: CredentialsError) -> AuthorizeSnapshotAccessError {
AuthorizeSnapshotAccessError::Credentials(err)
}
}
impl From<HttpDispatchError> for AuthorizeSnapshotAccessError {
fn from(err: HttpDispatchError) -> AuthorizeSnapshotAccessError {
AuthorizeSnapshotAccessError::HttpDispatch(err)
}
}
impl From<io::Error> for AuthorizeSnapshotAccessError {
fn from(err: io::Error) -> AuthorizeSnapshotAccessError {
AuthorizeSnapshotAccessError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for AuthorizeSnapshotAccessError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for AuthorizeSnapshotAccessError {
fn description(&self) -> &str {
match *self {
AuthorizeSnapshotAccessError::AuthorizationAlreadyExistsFault(ref cause) => cause,
AuthorizeSnapshotAccessError::AuthorizationQuotaExceededFault(ref cause) => cause,
AuthorizeSnapshotAccessError::ClusterSnapshotNotFoundFault(ref cause) => cause,
AuthorizeSnapshotAccessError::DependentServiceRequestThrottlingFault(ref cause) => {
cause
}
AuthorizeSnapshotAccessError::InvalidClusterSnapshotStateFault(ref cause) => cause,
AuthorizeSnapshotAccessError::LimitExceededFault(ref cause) => cause,
AuthorizeSnapshotAccessError::Validation(ref cause) => cause,
AuthorizeSnapshotAccessError::Credentials(ref err) => err.description(),
AuthorizeSnapshotAccessError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
AuthorizeSnapshotAccessError::ParseError(ref cause) => cause,
AuthorizeSnapshotAccessError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum CopyClusterSnapshotError {
ClusterSnapshotAlreadyExistsFault(String),
ClusterSnapshotNotFoundFault(String),
ClusterSnapshotQuotaExceededFault(String),
InvalidClusterSnapshotStateFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CopyClusterSnapshotError {
pub fn from_response(res: BufferedHttpResponse) -> CopyClusterSnapshotError {
{
let reader = EventReader::new(res.body.as_slice());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"ClusterSnapshotAlreadyExists" => {
return CopyClusterSnapshotError::ClusterSnapshotAlreadyExistsFault(
String::from(parsed_error.message),
)
}
"ClusterSnapshotNotFound" => {
return CopyClusterSnapshotError::ClusterSnapshotNotFoundFault(String::from(
parsed_error.message,
))
}
"ClusterSnapshotQuotaExceeded" => {
return CopyClusterSnapshotError::ClusterSnapshotQuotaExceededFault(
String::from(parsed_error.message),
)
}
"InvalidClusterSnapshotState" => {
return CopyClusterSnapshotError::InvalidClusterSnapshotStateFault(
String::from(parsed_error.message),
)
}
_ => {}
}
}
}
CopyClusterSnapshotError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for CopyClusterSnapshotError {
fn from(err: XmlParseError) -> CopyClusterSnapshotError {
let XmlParseError(message) = err;
CopyClusterSnapshotError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for CopyClusterSnapshotError {
fn from(err: CredentialsError) -> CopyClusterSnapshotError {
CopyClusterSnapshotError::Credentials(err)
}
}
impl From<HttpDispatchError> for CopyClusterSnapshotError {
fn from(err: HttpDispatchError) -> CopyClusterSnapshotError {
CopyClusterSnapshotError::HttpDispatch(err)
}
}
impl From<io::Error> for CopyClusterSnapshotError {
fn from(err: io::Error) -> CopyClusterSnapshotError {
CopyClusterSnapshotError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CopyClusterSnapshotError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CopyClusterSnapshotError {
fn description(&self) -> &str {
match *self {
CopyClusterSnapshotError::ClusterSnapshotAlreadyExistsFault(ref cause) => cause,
CopyClusterSnapshotError::ClusterSnapshotNotFoundFault(ref cause) => cause,
CopyClusterSnapshotError::ClusterSnapshotQuotaExceededFault(ref cause) => cause,
CopyClusterSnapshotError::InvalidClusterSnapshotStateFault(ref cause) => cause,
CopyClusterSnapshotError::Validation(ref cause) => cause,
CopyClusterSnapshotError::Credentials(ref err) => err.description(),
CopyClusterSnapshotError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
CopyClusterSnapshotError::ParseError(ref cause) => cause,
CopyClusterSnapshotError::Unknown(_) => "unknown error",
}
}
}
#[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),
InvalidSubnet(String),
InvalidTagFault(String),
InvalidVPCNetworkStateFault(String),
LimitExceededFault(String),
NumberOfNodesPerClusterLimitExceededFault(String),
NumberOfNodesQuotaExceededFault(String),
TagLimitExceededFault(String),
UnauthorizedOperation(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CreateClusterError {
pub fn from_response(res: BufferedHttpResponse) -> CreateClusterError {
{
let reader = EventReader::new(res.body.as_slice());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"ClusterAlreadyExists" => {
return CreateClusterError::ClusterAlreadyExistsFault(String::from(
parsed_error.message,
))
}
"ClusterParameterGroupNotFound" => {
return CreateClusterError::ClusterParameterGroupNotFoundFault(String::from(
parsed_error.message,
))
}
"ClusterQuotaExceeded" => {
return CreateClusterError::ClusterQuotaExceededFault(String::from(
parsed_error.message,
))
}
"ClusterSecurityGroupNotFound" => {
return CreateClusterError::ClusterSecurityGroupNotFoundFault(String::from(
parsed_error.message,
))
}
"ClusterSubnetGroupNotFoundFault" => {
return CreateClusterError::ClusterSubnetGroupNotFoundFault(String::from(
parsed_error.message,
))
}
"DependentServiceRequestThrottlingFault" => {
return CreateClusterError::DependentServiceRequestThrottlingFault(
String::from(parsed_error.message),
)
}
"HsmClientCertificateNotFoundFault" => {
return CreateClusterError::HsmClientCertificateNotFoundFault(String::from(
parsed_error.message,
))
}
"HsmConfigurationNotFoundFault" => {
return CreateClusterError::HsmConfigurationNotFoundFault(String::from(
parsed_error.message,
))
}
"InsufficientClusterCapacity" => {
return CreateClusterError::InsufficientClusterCapacityFault(String::from(
parsed_error.message,
))
}
"InvalidClusterSubnetGroupStateFault" => {
return CreateClusterError::InvalidClusterSubnetGroupStateFault(
String::from(parsed_error.message),
)
}
"InvalidClusterTrack" => {
return CreateClusterError::InvalidClusterTrackFault(String::from(
parsed_error.message,
))
}
"InvalidElasticIpFault" => {
return CreateClusterError::InvalidElasticIpFault(String::from(
parsed_error.message,
))
}
"InvalidSubnet" => {
return CreateClusterError::InvalidSubnet(String::from(parsed_error.message))
}
"InvalidTagFault" => {
return CreateClusterError::InvalidTagFault(String::from(
parsed_error.message,
))
}
"InvalidVPCNetworkStateFault" => {
return CreateClusterError::InvalidVPCNetworkStateFault(String::from(
parsed_error.message,
))
}
"LimitExceededFault" => {
return CreateClusterError::LimitExceededFault(String::from(
parsed_error.message,
))
}
"NumberOfNodesPerClusterLimitExceeded" => {
return CreateClusterError::NumberOfNodesPerClusterLimitExceededFault(
String::from(parsed_error.message),
)
}
"NumberOfNodesQuotaExceeded" => {
return CreateClusterError::NumberOfNodesQuotaExceededFault(String::from(
parsed_error.message,
))
}
"TagLimitExceededFault" => {
return CreateClusterError::TagLimitExceededFault(String::from(
parsed_error.message,
))
}
"UnauthorizedOperation" => {
return CreateClusterError::UnauthorizedOperation(String::from(
parsed_error.message,
))
}
_ => {}
}
}
}
CreateClusterError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for CreateClusterError {
fn from(err: XmlParseError) -> CreateClusterError {
let XmlParseError(message) = err;
CreateClusterError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for CreateClusterError {
fn from(err: CredentialsError) -> CreateClusterError {
CreateClusterError::Credentials(err)
}
}
impl From<HttpDispatchError> for CreateClusterError {
fn from(err: HttpDispatchError) -> CreateClusterError {
CreateClusterError::HttpDispatch(err)
}
}
impl From<io::Error> for CreateClusterError {
fn from(err: io::Error) -> CreateClusterError {
CreateClusterError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CreateClusterError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateClusterError {
fn description(&self) -> &str {
match *self {
CreateClusterError::ClusterAlreadyExistsFault(ref cause) => cause,
CreateClusterError::ClusterParameterGroupNotFoundFault(ref cause) => cause,
CreateClusterError::ClusterQuotaExceededFault(ref cause) => cause,
CreateClusterError::ClusterSecurityGroupNotFoundFault(ref cause) => cause,
CreateClusterError::ClusterSubnetGroupNotFoundFault(ref cause) => cause,
CreateClusterError::DependentServiceRequestThrottlingFault(ref cause) => cause,
CreateClusterError::HsmClientCertificateNotFoundFault(ref cause) => cause,
CreateClusterError::HsmConfigurationNotFoundFault(ref cause) => cause,
CreateClusterError::InsufficientClusterCapacityFault(ref cause) => cause,
CreateClusterError::InvalidClusterSubnetGroupStateFault(ref cause) => cause,
CreateClusterError::InvalidClusterTrackFault(ref cause) => cause,
CreateClusterError::InvalidElasticIpFault(ref cause) => cause,
CreateClusterError::InvalidSubnet(ref cause) => cause,
CreateClusterError::InvalidTagFault(ref cause) => cause,
CreateClusterError::InvalidVPCNetworkStateFault(ref cause) => cause,
CreateClusterError::LimitExceededFault(ref cause) => cause,
CreateClusterError::NumberOfNodesPerClusterLimitExceededFault(ref cause) => cause,
CreateClusterError::NumberOfNodesQuotaExceededFault(ref cause) => cause,
CreateClusterError::TagLimitExceededFault(ref cause) => cause,
CreateClusterError::UnauthorizedOperation(ref cause) => cause,
CreateClusterError::Validation(ref cause) => cause,
CreateClusterError::Credentials(ref err) => err.description(),
CreateClusterError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
CreateClusterError::ParseError(ref cause) => cause,
CreateClusterError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateClusterParameterGroupError {
ClusterParameterGroupAlreadyExistsFault(String),
ClusterParameterGroupQuotaExceededFault(String),
InvalidTagFault(String),
TagLimitExceededFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CreateClusterParameterGroupError {
pub fn from_response(res: BufferedHttpResponse) -> CreateClusterParameterGroupError {
{
let reader = EventReader::new(res.body.as_slice());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"ClusterParameterGroupAlreadyExists" => return CreateClusterParameterGroupError::ClusterParameterGroupAlreadyExistsFault(String::from(parsed_error.message)),"ClusterParameterGroupQuotaExceeded" => return CreateClusterParameterGroupError::ClusterParameterGroupQuotaExceededFault(String::from(parsed_error.message)),"InvalidTagFault" => return CreateClusterParameterGroupError::InvalidTagFault(String::from(parsed_error.message)),"TagLimitExceededFault" => return CreateClusterParameterGroupError::TagLimitExceededFault(String::from(parsed_error.message)),_ => {}
}
}
}
CreateClusterParameterGroupError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for CreateClusterParameterGroupError {
fn from(err: XmlParseError) -> CreateClusterParameterGroupError {
let XmlParseError(message) = err;
CreateClusterParameterGroupError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for CreateClusterParameterGroupError {
fn from(err: CredentialsError) -> CreateClusterParameterGroupError {
CreateClusterParameterGroupError::Credentials(err)
}
}
impl From<HttpDispatchError> for CreateClusterParameterGroupError {
fn from(err: HttpDispatchError) -> CreateClusterParameterGroupError {
CreateClusterParameterGroupError::HttpDispatch(err)
}
}
impl From<io::Error> for CreateClusterParameterGroupError {
fn from(err: io::Error) -> CreateClusterParameterGroupError {
CreateClusterParameterGroupError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CreateClusterParameterGroupError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateClusterParameterGroupError {
fn description(&self) -> &str {
match *self {
CreateClusterParameterGroupError::ClusterParameterGroupAlreadyExistsFault(
ref cause,
) => cause,
CreateClusterParameterGroupError::ClusterParameterGroupQuotaExceededFault(
ref cause,
) => cause,
CreateClusterParameterGroupError::InvalidTagFault(ref cause) => cause,
CreateClusterParameterGroupError::TagLimitExceededFault(ref cause) => cause,
CreateClusterParameterGroupError::Validation(ref cause) => cause,
CreateClusterParameterGroupError::Credentials(ref err) => err.description(),
CreateClusterParameterGroupError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
CreateClusterParameterGroupError::ParseError(ref cause) => cause,
CreateClusterParameterGroupError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateClusterSecurityGroupError {
ClusterSecurityGroupAlreadyExistsFault(String),
ClusterSecurityGroupQuotaExceededFault(String),
InvalidTagFault(String),
TagLimitExceededFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CreateClusterSecurityGroupError {
pub fn from_response(res: BufferedHttpResponse) -> CreateClusterSecurityGroupError {
{
let reader = EventReader::new(res.body.as_slice());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"ClusterSecurityGroupAlreadyExists" => return CreateClusterSecurityGroupError::ClusterSecurityGroupAlreadyExistsFault(String::from(parsed_error.message)),"QuotaExceeded.ClusterSecurityGroup" => return CreateClusterSecurityGroupError::ClusterSecurityGroupQuotaExceededFault(String::from(parsed_error.message)),"InvalidTagFault" => return CreateClusterSecurityGroupError::InvalidTagFault(String::from(parsed_error.message)),"TagLimitExceededFault" => return CreateClusterSecurityGroupError::TagLimitExceededFault(String::from(parsed_error.message)),_ => {}
}
}
}
CreateClusterSecurityGroupError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for CreateClusterSecurityGroupError {
fn from(err: XmlParseError) -> CreateClusterSecurityGroupError {
let XmlParseError(message) = err;
CreateClusterSecurityGroupError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for CreateClusterSecurityGroupError {
fn from(err: CredentialsError) -> CreateClusterSecurityGroupError {
CreateClusterSecurityGroupError::Credentials(err)
}
}
impl From<HttpDispatchError> for CreateClusterSecurityGroupError {
fn from(err: HttpDispatchError) -> CreateClusterSecurityGroupError {
CreateClusterSecurityGroupError::HttpDispatch(err)
}
}
impl From<io::Error> for CreateClusterSecurityGroupError {
fn from(err: io::Error) -> CreateClusterSecurityGroupError {
CreateClusterSecurityGroupError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CreateClusterSecurityGroupError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateClusterSecurityGroupError {
fn description(&self) -> &str {
match *self {
CreateClusterSecurityGroupError::ClusterSecurityGroupAlreadyExistsFault(ref cause) => {
cause
}
CreateClusterSecurityGroupError::ClusterSecurityGroupQuotaExceededFault(ref cause) => {
cause
}
CreateClusterSecurityGroupError::InvalidTagFault(ref cause) => cause,
CreateClusterSecurityGroupError::TagLimitExceededFault(ref cause) => cause,
CreateClusterSecurityGroupError::Validation(ref cause) => cause,
CreateClusterSecurityGroupError::Credentials(ref err) => err.description(),
CreateClusterSecurityGroupError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
CreateClusterSecurityGroupError::ParseError(ref cause) => cause,
CreateClusterSecurityGroupError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateClusterSnapshotError {
ClusterNotFoundFault(String),
ClusterSnapshotAlreadyExistsFault(String),
ClusterSnapshotQuotaExceededFault(String),
InvalidClusterStateFault(String),
InvalidTagFault(String),
TagLimitExceededFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CreateClusterSnapshotError {
pub fn from_response(res: BufferedHttpResponse) -> CreateClusterSnapshotError {
{
let reader = EventReader::new(res.body.as_slice());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"ClusterNotFound" => {
return CreateClusterSnapshotError::ClusterNotFoundFault(String::from(
parsed_error.message,
))
}
"ClusterSnapshotAlreadyExists" => {
return CreateClusterSnapshotError::ClusterSnapshotAlreadyExistsFault(
String::from(parsed_error.message),
)
}
"ClusterSnapshotQuotaExceeded" => {
return CreateClusterSnapshotError::ClusterSnapshotQuotaExceededFault(
String::from(parsed_error.message),
)
}
"InvalidClusterState" => {
return CreateClusterSnapshotError::InvalidClusterStateFault(String::from(
parsed_error.message,
))
}
"InvalidTagFault" => {
return CreateClusterSnapshotError::InvalidTagFault(String::from(
parsed_error.message,
))
}
"TagLimitExceededFault" => {
return CreateClusterSnapshotError::TagLimitExceededFault(String::from(
parsed_error.message,
))
}
_ => {}
}
}
}
CreateClusterSnapshotError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for CreateClusterSnapshotError {
fn from(err: XmlParseError) -> CreateClusterSnapshotError {
let XmlParseError(message) = err;
CreateClusterSnapshotError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for CreateClusterSnapshotError {
fn from(err: CredentialsError) -> CreateClusterSnapshotError {
CreateClusterSnapshotError::Credentials(err)
}
}
impl From<HttpDispatchError> for CreateClusterSnapshotError {
fn from(err: HttpDispatchError) -> CreateClusterSnapshotError {
CreateClusterSnapshotError::HttpDispatch(err)
}
}
impl From<io::Error> for CreateClusterSnapshotError {
fn from(err: io::Error) -> CreateClusterSnapshotError {
CreateClusterSnapshotError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CreateClusterSnapshotError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateClusterSnapshotError {
fn description(&self) -> &str {
match *self {
CreateClusterSnapshotError::ClusterNotFoundFault(ref cause) => cause,
CreateClusterSnapshotError::ClusterSnapshotAlreadyExistsFault(ref cause) => cause,
CreateClusterSnapshotError::ClusterSnapshotQuotaExceededFault(ref cause) => cause,
CreateClusterSnapshotError::InvalidClusterStateFault(ref cause) => cause,
CreateClusterSnapshotError::InvalidTagFault(ref cause) => cause,
CreateClusterSnapshotError::TagLimitExceededFault(ref cause) => cause,
CreateClusterSnapshotError::Validation(ref cause) => cause,
CreateClusterSnapshotError::Credentials(ref err) => err.description(),
CreateClusterSnapshotError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
CreateClusterSnapshotError::ParseError(ref cause) => cause,
CreateClusterSnapshotError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateClusterSubnetGroupError {
ClusterSubnetGroupAlreadyExistsFault(String),
ClusterSubnetGroupQuotaExceededFault(String),
ClusterSubnetQuotaExceededFault(String),
DependentServiceRequestThrottlingFault(String),
InvalidSubnet(String),
InvalidTagFault(String),
TagLimitExceededFault(String),
UnauthorizedOperation(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CreateClusterSubnetGroupError {
pub fn from_response(res: BufferedHttpResponse) -> CreateClusterSubnetGroupError {
{
let reader = EventReader::new(res.body.as_slice());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"ClusterSubnetGroupAlreadyExists" => {
return CreateClusterSubnetGroupError::ClusterSubnetGroupAlreadyExistsFault(
String::from(parsed_error.message),
)
}
"ClusterSubnetGroupQuotaExceeded" => {
return CreateClusterSubnetGroupError::ClusterSubnetGroupQuotaExceededFault(
String::from(parsed_error.message),
)
}
"ClusterSubnetQuotaExceededFault" => {
return CreateClusterSubnetGroupError::ClusterSubnetQuotaExceededFault(
String::from(parsed_error.message),
)
}
"DependentServiceRequestThrottlingFault" => {
return CreateClusterSubnetGroupError::DependentServiceRequestThrottlingFault(
String::from(parsed_error.message),
)
}
"InvalidSubnet" => {
return CreateClusterSubnetGroupError::InvalidSubnet(String::from(
parsed_error.message,
))
}
"InvalidTagFault" => {
return CreateClusterSubnetGroupError::InvalidTagFault(String::from(
parsed_error.message,
))
}
"TagLimitExceededFault" => {
return CreateClusterSubnetGroupError::TagLimitExceededFault(String::from(
parsed_error.message,
))
}
"UnauthorizedOperation" => {
return CreateClusterSubnetGroupError::UnauthorizedOperation(String::from(
parsed_error.message,
))
}
_ => {}
}
}
}
CreateClusterSubnetGroupError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for CreateClusterSubnetGroupError {
fn from(err: XmlParseError) -> CreateClusterSubnetGroupError {
let XmlParseError(message) = err;
CreateClusterSubnetGroupError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for CreateClusterSubnetGroupError {
fn from(err: CredentialsError) -> CreateClusterSubnetGroupError {
CreateClusterSubnetGroupError::Credentials(err)
}
}
impl From<HttpDispatchError> for CreateClusterSubnetGroupError {
fn from(err: HttpDispatchError) -> CreateClusterSubnetGroupError {
CreateClusterSubnetGroupError::HttpDispatch(err)
}
}
impl From<io::Error> for CreateClusterSubnetGroupError {
fn from(err: io::Error) -> CreateClusterSubnetGroupError {
CreateClusterSubnetGroupError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CreateClusterSubnetGroupError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateClusterSubnetGroupError {
fn description(&self) -> &str {
match *self {
CreateClusterSubnetGroupError::ClusterSubnetGroupAlreadyExistsFault(ref cause) => cause,
CreateClusterSubnetGroupError::ClusterSubnetGroupQuotaExceededFault(ref cause) => cause,
CreateClusterSubnetGroupError::ClusterSubnetQuotaExceededFault(ref cause) => cause,
CreateClusterSubnetGroupError::DependentServiceRequestThrottlingFault(ref cause) => {
cause
}
CreateClusterSubnetGroupError::InvalidSubnet(ref cause) => cause,
CreateClusterSubnetGroupError::InvalidTagFault(ref cause) => cause,
CreateClusterSubnetGroupError::TagLimitExceededFault(ref cause) => cause,
CreateClusterSubnetGroupError::UnauthorizedOperation(ref cause) => cause,
CreateClusterSubnetGroupError::Validation(ref cause) => cause,
CreateClusterSubnetGroupError::Credentials(ref err) => err.description(),
CreateClusterSubnetGroupError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
CreateClusterSubnetGroupError::ParseError(ref cause) => cause,
CreateClusterSubnetGroupError::Unknown(_) => "unknown error",
}
}
}
#[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),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CreateEventSubscriptionError {
pub fn from_response(res: BufferedHttpResponse) -> CreateEventSubscriptionError {
{
let reader = EventReader::new(res.body.as_slice());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"EventSubscriptionQuotaExceeded" => {
return CreateEventSubscriptionError::EventSubscriptionQuotaExceededFault(
String::from(parsed_error.message),
)
}
"InvalidTagFault" => {
return CreateEventSubscriptionError::InvalidTagFault(String::from(
parsed_error.message,
))
}
"SNSInvalidTopic" => {
return CreateEventSubscriptionError::SNSInvalidTopicFault(String::from(
parsed_error.message,
))
}
"SNSNoAuthorization" => {
return CreateEventSubscriptionError::SNSNoAuthorizationFault(String::from(
parsed_error.message,
))
}
"SNSTopicArnNotFound" => {
return CreateEventSubscriptionError::SNSTopicArnNotFoundFault(String::from(
parsed_error.message,
))
}
"SourceNotFound" => {
return CreateEventSubscriptionError::SourceNotFoundFault(String::from(
parsed_error.message,
))
}
"SubscriptionAlreadyExist" => {
return CreateEventSubscriptionError::SubscriptionAlreadyExistFault(
String::from(parsed_error.message),
)
}
"SubscriptionCategoryNotFound" => {
return CreateEventSubscriptionError::SubscriptionCategoryNotFoundFault(
String::from(parsed_error.message),
)
}
"SubscriptionEventIdNotFound" => {
return CreateEventSubscriptionError::SubscriptionEventIdNotFoundFault(
String::from(parsed_error.message),
)
}
"SubscriptionSeverityNotFound" => {
return CreateEventSubscriptionError::SubscriptionSeverityNotFoundFault(
String::from(parsed_error.message),
)
}
"TagLimitExceededFault" => {
return CreateEventSubscriptionError::TagLimitExceededFault(String::from(
parsed_error.message,
))
}
_ => {}
}
}
}
CreateEventSubscriptionError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for CreateEventSubscriptionError {
fn from(err: XmlParseError) -> CreateEventSubscriptionError {
let XmlParseError(message) = err;
CreateEventSubscriptionError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for CreateEventSubscriptionError {
fn from(err: CredentialsError) -> CreateEventSubscriptionError {
CreateEventSubscriptionError::Credentials(err)
}
}
impl From<HttpDispatchError> for CreateEventSubscriptionError {
fn from(err: HttpDispatchError) -> CreateEventSubscriptionError {
CreateEventSubscriptionError::HttpDispatch(err)
}
}
impl From<io::Error> for CreateEventSubscriptionError {
fn from(err: io::Error) -> CreateEventSubscriptionError {
CreateEventSubscriptionError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CreateEventSubscriptionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateEventSubscriptionError {
fn description(&self) -> &str {
match *self {
CreateEventSubscriptionError::EventSubscriptionQuotaExceededFault(ref cause) => cause,
CreateEventSubscriptionError::InvalidTagFault(ref cause) => cause,
CreateEventSubscriptionError::SNSInvalidTopicFault(ref cause) => cause,
CreateEventSubscriptionError::SNSNoAuthorizationFault(ref cause) => cause,
CreateEventSubscriptionError::SNSTopicArnNotFoundFault(ref cause) => cause,
CreateEventSubscriptionError::SourceNotFoundFault(ref cause) => cause,
CreateEventSubscriptionError::SubscriptionAlreadyExistFault(ref cause) => cause,
CreateEventSubscriptionError::SubscriptionCategoryNotFoundFault(ref cause) => cause,
CreateEventSubscriptionError::SubscriptionEventIdNotFoundFault(ref cause) => cause,
CreateEventSubscriptionError::SubscriptionSeverityNotFoundFault(ref cause) => cause,
CreateEventSubscriptionError::TagLimitExceededFault(ref cause) => cause,
CreateEventSubscriptionError::Validation(ref cause) => cause,
CreateEventSubscriptionError::Credentials(ref err) => err.description(),
CreateEventSubscriptionError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
CreateEventSubscriptionError::ParseError(ref cause) => cause,
CreateEventSubscriptionError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateHsmClientCertificateError {
HsmClientCertificateAlreadyExistsFault(String),
HsmClientCertificateQuotaExceededFault(String),
InvalidTagFault(String),
TagLimitExceededFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CreateHsmClientCertificateError {
pub fn from_response(res: BufferedHttpResponse) -> CreateHsmClientCertificateError {
{
let reader = EventReader::new(res.body.as_slice());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"HsmClientCertificateAlreadyExistsFault" => return CreateHsmClientCertificateError::HsmClientCertificateAlreadyExistsFault(String::from(parsed_error.message)),"HsmClientCertificateQuotaExceededFault" => return CreateHsmClientCertificateError::HsmClientCertificateQuotaExceededFault(String::from(parsed_error.message)),"InvalidTagFault" => return CreateHsmClientCertificateError::InvalidTagFault(String::from(parsed_error.message)),"TagLimitExceededFault" => return CreateHsmClientCertificateError::TagLimitExceededFault(String::from(parsed_error.message)),_ => {}
}
}
}
CreateHsmClientCertificateError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for CreateHsmClientCertificateError {
fn from(err: XmlParseError) -> CreateHsmClientCertificateError {
let XmlParseError(message) = err;
CreateHsmClientCertificateError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for CreateHsmClientCertificateError {
fn from(err: CredentialsError) -> CreateHsmClientCertificateError {
CreateHsmClientCertificateError::Credentials(err)
}
}
impl From<HttpDispatchError> for CreateHsmClientCertificateError {
fn from(err: HttpDispatchError) -> CreateHsmClientCertificateError {
CreateHsmClientCertificateError::HttpDispatch(err)
}
}
impl From<io::Error> for CreateHsmClientCertificateError {
fn from(err: io::Error) -> CreateHsmClientCertificateError {
CreateHsmClientCertificateError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CreateHsmClientCertificateError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateHsmClientCertificateError {
fn description(&self) -> &str {
match *self {
CreateHsmClientCertificateError::HsmClientCertificateAlreadyExistsFault(ref cause) => {
cause
}
CreateHsmClientCertificateError::HsmClientCertificateQuotaExceededFault(ref cause) => {
cause
}
CreateHsmClientCertificateError::InvalidTagFault(ref cause) => cause,
CreateHsmClientCertificateError::TagLimitExceededFault(ref cause) => cause,
CreateHsmClientCertificateError::Validation(ref cause) => cause,
CreateHsmClientCertificateError::Credentials(ref err) => err.description(),
CreateHsmClientCertificateError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
CreateHsmClientCertificateError::ParseError(ref cause) => cause,
CreateHsmClientCertificateError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateHsmConfigurationError {
HsmConfigurationAlreadyExistsFault(String),
HsmConfigurationQuotaExceededFault(String),
InvalidTagFault(String),
TagLimitExceededFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CreateHsmConfigurationError {
pub fn from_response(res: BufferedHttpResponse) -> CreateHsmConfigurationError {
{
let reader = EventReader::new(res.body.as_slice());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"HsmConfigurationAlreadyExistsFault" => {
return CreateHsmConfigurationError::HsmConfigurationAlreadyExistsFault(
String::from(parsed_error.message),
)
}
"HsmConfigurationQuotaExceededFault" => {
return CreateHsmConfigurationError::HsmConfigurationQuotaExceededFault(
String::from(parsed_error.message),
)
}
"InvalidTagFault" => {
return CreateHsmConfigurationError::InvalidTagFault(String::from(
parsed_error.message,
))
}
"TagLimitExceededFault" => {
return CreateHsmConfigurationError::TagLimitExceededFault(String::from(
parsed_error.message,
))
}
_ => {}
}
}
}
CreateHsmConfigurationError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for CreateHsmConfigurationError {
fn from(err: XmlParseError) -> CreateHsmConfigurationError {
let XmlParseError(message) = err;
CreateHsmConfigurationError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for CreateHsmConfigurationError {
fn from(err: CredentialsError) -> CreateHsmConfigurationError {
CreateHsmConfigurationError::Credentials(err)
}
}
impl From<HttpDispatchError> for CreateHsmConfigurationError {
fn from(err: HttpDispatchError) -> CreateHsmConfigurationError {
CreateHsmConfigurationError::HttpDispatch(err)
}
}
impl From<io::Error> for CreateHsmConfigurationError {
fn from(err: io::Error) -> CreateHsmConfigurationError {
CreateHsmConfigurationError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CreateHsmConfigurationError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateHsmConfigurationError {
fn description(&self) -> &str {
match *self {
CreateHsmConfigurationError::HsmConfigurationAlreadyExistsFault(ref cause) => cause,
CreateHsmConfigurationError::HsmConfigurationQuotaExceededFault(ref cause) => cause,
CreateHsmConfigurationError::InvalidTagFault(ref cause) => cause,
CreateHsmConfigurationError::TagLimitExceededFault(ref cause) => cause,
CreateHsmConfigurationError::Validation(ref cause) => cause,
CreateHsmConfigurationError::Credentials(ref err) => err.description(),
CreateHsmConfigurationError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
CreateHsmConfigurationError::ParseError(ref cause) => cause,
CreateHsmConfigurationError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateSnapshotCopyGrantError {
DependentServiceRequestThrottlingFault(String),
InvalidTagFault(String),
LimitExceededFault(String),
SnapshotCopyGrantAlreadyExistsFault(String),
SnapshotCopyGrantQuotaExceededFault(String),
TagLimitExceededFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CreateSnapshotCopyGrantError {
pub fn from_response(res: BufferedHttpResponse) -> CreateSnapshotCopyGrantError {
{
let reader = EventReader::new(res.body.as_slice());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"DependentServiceRequestThrottlingFault" => {
return CreateSnapshotCopyGrantError::DependentServiceRequestThrottlingFault(
String::from(parsed_error.message),
)
}
"InvalidTagFault" => {
return CreateSnapshotCopyGrantError::InvalidTagFault(String::from(
parsed_error.message,
))
}
"LimitExceededFault" => {
return CreateSnapshotCopyGrantError::LimitExceededFault(String::from(
parsed_error.message,
))
}
"SnapshotCopyGrantAlreadyExistsFault" => {
return CreateSnapshotCopyGrantError::SnapshotCopyGrantAlreadyExistsFault(
String::from(parsed_error.message),
)
}
"SnapshotCopyGrantQuotaExceededFault" => {
return CreateSnapshotCopyGrantError::SnapshotCopyGrantQuotaExceededFault(
String::from(parsed_error.message),
)
}
"TagLimitExceededFault" => {
return CreateSnapshotCopyGrantError::TagLimitExceededFault(String::from(
parsed_error.message,
))
}
_ => {}
}
}
}
CreateSnapshotCopyGrantError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for CreateSnapshotCopyGrantError {
fn from(err: XmlParseError) -> CreateSnapshotCopyGrantError {
let XmlParseError(message) = err;
CreateSnapshotCopyGrantError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for CreateSnapshotCopyGrantError {
fn from(err: CredentialsError) -> CreateSnapshotCopyGrantError {
CreateSnapshotCopyGrantError::Credentials(err)
}
}
impl From<HttpDispatchError> for CreateSnapshotCopyGrantError {
fn from(err: HttpDispatchError) -> CreateSnapshotCopyGrantError {
CreateSnapshotCopyGrantError::HttpDispatch(err)
}
}
impl From<io::Error> for CreateSnapshotCopyGrantError {
fn from(err: io::Error) -> CreateSnapshotCopyGrantError {
CreateSnapshotCopyGrantError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CreateSnapshotCopyGrantError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateSnapshotCopyGrantError {
fn description(&self) -> &str {
match *self {
CreateSnapshotCopyGrantError::DependentServiceRequestThrottlingFault(ref cause) => {
cause
}
CreateSnapshotCopyGrantError::InvalidTagFault(ref cause) => cause,
CreateSnapshotCopyGrantError::LimitExceededFault(ref cause) => cause,
CreateSnapshotCopyGrantError::SnapshotCopyGrantAlreadyExistsFault(ref cause) => cause,
CreateSnapshotCopyGrantError::SnapshotCopyGrantQuotaExceededFault(ref cause) => cause,
CreateSnapshotCopyGrantError::TagLimitExceededFault(ref cause) => cause,
CreateSnapshotCopyGrantError::Validation(ref cause) => cause,
CreateSnapshotCopyGrantError::Credentials(ref err) => err.description(),
CreateSnapshotCopyGrantError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
CreateSnapshotCopyGrantError::ParseError(ref cause) => cause,
CreateSnapshotCopyGrantError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateTagsError {
InvalidTagFault(String),
ResourceNotFoundFault(String),
TagLimitExceededFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CreateTagsError {
pub fn from_response(res: BufferedHttpResponse) -> CreateTagsError {
{
let reader = EventReader::new(res.body.as_slice());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"InvalidTagFault" => {
return CreateTagsError::InvalidTagFault(String::from(parsed_error.message))
}
"ResourceNotFoundFault" => {
return CreateTagsError::ResourceNotFoundFault(String::from(
parsed_error.message,
))
}
"TagLimitExceededFault" => {
return CreateTagsError::TagLimitExceededFault(String::from(
parsed_error.message,
))
}
_ => {}
}
}
}
CreateTagsError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for CreateTagsError {
fn from(err: XmlParseError) -> CreateTagsError {
let XmlParseError(message) = err;
CreateTagsError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for CreateTagsError {
fn from(err: CredentialsError) -> CreateTagsError {
CreateTagsError::Credentials(err)
}
}
impl From<HttpDispatchError> for CreateTagsError {
fn from(err: HttpDispatchError) -> CreateTagsError {
CreateTagsError::HttpDispatch(err)
}
}
impl From<io::Error> for CreateTagsError {
fn from(err: io::Error) -> CreateTagsError {
CreateTagsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CreateTagsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateTagsError {
fn description(&self) -> &str {
match *self {
CreateTagsError::InvalidTagFault(ref cause) => cause,
CreateTagsError::ResourceNotFoundFault(ref cause) => cause,
CreateTagsError::TagLimitExceededFault(ref cause) => cause,
CreateTagsError::Validation(ref cause) => cause,
CreateTagsError::Credentials(ref err) => err.description(),
CreateTagsError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
CreateTagsError::ParseError(ref cause) => cause,
CreateTagsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteClusterError {
ClusterNotFoundFault(String),
ClusterSnapshotAlreadyExistsFault(String),
ClusterSnapshotQuotaExceededFault(String),
InvalidClusterStateFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DeleteClusterError {
pub fn from_response(res: BufferedHttpResponse) -> DeleteClusterError {
{
let reader = EventReader::new(res.body.as_slice());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"ClusterNotFound" => {
return DeleteClusterError::ClusterNotFoundFault(String::from(
parsed_error.message,
))
}
"ClusterSnapshotAlreadyExists" => {
return DeleteClusterError::ClusterSnapshotAlreadyExistsFault(String::from(
parsed_error.message,
))
}
"ClusterSnapshotQuotaExceeded" => {
return DeleteClusterError::ClusterSnapshotQuotaExceededFault(String::from(
parsed_error.message,
))
}
"InvalidClusterState" => {
return DeleteClusterError::InvalidClusterStateFault(String::from(
parsed_error.message,
))
}
_ => {}
}
}
}
DeleteClusterError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for DeleteClusterError {
fn from(err: XmlParseError) -> DeleteClusterError {
let XmlParseError(message) = err;
DeleteClusterError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DeleteClusterError {
fn from(err: CredentialsError) -> DeleteClusterError {
DeleteClusterError::Credentials(err)
}
}
impl From<HttpDispatchError> for DeleteClusterError {
fn from(err: HttpDispatchError) -> DeleteClusterError {
DeleteClusterError::HttpDispatch(err)
}
}
impl From<io::Error> for DeleteClusterError {
fn from(err: io::Error) -> DeleteClusterError {
DeleteClusterError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DeleteClusterError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteClusterError {
fn description(&self) -> &str {
match *self {
DeleteClusterError::ClusterNotFoundFault(ref cause) => cause,
DeleteClusterError::ClusterSnapshotAlreadyExistsFault(ref cause) => cause,
DeleteClusterError::ClusterSnapshotQuotaExceededFault(ref cause) => cause,
DeleteClusterError::InvalidClusterStateFault(ref cause) => cause,
DeleteClusterError::Validation(ref cause) => cause,
DeleteClusterError::Credentials(ref err) => err.description(),
DeleteClusterError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
DeleteClusterError::ParseError(ref cause) => cause,
DeleteClusterError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteClusterParameterGroupError {
ClusterParameterGroupNotFoundFault(String),
InvalidClusterParameterGroupStateFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DeleteClusterParameterGroupError {
pub fn from_response(res: BufferedHttpResponse) -> DeleteClusterParameterGroupError {
{
let reader = EventReader::new(res.body.as_slice());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"ClusterParameterGroupNotFound" => return DeleteClusterParameterGroupError::ClusterParameterGroupNotFoundFault(String::from(parsed_error.message)),"InvalidClusterParameterGroupState" => return DeleteClusterParameterGroupError::InvalidClusterParameterGroupStateFault(String::from(parsed_error.message)),_ => {}
}
}
}
DeleteClusterParameterGroupError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for DeleteClusterParameterGroupError {
fn from(err: XmlParseError) -> DeleteClusterParameterGroupError {
let XmlParseError(message) = err;
DeleteClusterParameterGroupError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DeleteClusterParameterGroupError {
fn from(err: CredentialsError) -> DeleteClusterParameterGroupError {
DeleteClusterParameterGroupError::Credentials(err)
}
}
impl From<HttpDispatchError> for DeleteClusterParameterGroupError {
fn from(err: HttpDispatchError) -> DeleteClusterParameterGroupError {
DeleteClusterParameterGroupError::HttpDispatch(err)
}
}
impl From<io::Error> for DeleteClusterParameterGroupError {
fn from(err: io::Error) -> DeleteClusterParameterGroupError {
DeleteClusterParameterGroupError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DeleteClusterParameterGroupError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteClusterParameterGroupError {
fn description(&self) -> &str {
match *self {
DeleteClusterParameterGroupError::ClusterParameterGroupNotFoundFault(ref cause) => {
cause
}
DeleteClusterParameterGroupError::InvalidClusterParameterGroupStateFault(ref cause) => {
cause
}
DeleteClusterParameterGroupError::Validation(ref cause) => cause,
DeleteClusterParameterGroupError::Credentials(ref err) => err.description(),
DeleteClusterParameterGroupError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DeleteClusterParameterGroupError::ParseError(ref cause) => cause,
DeleteClusterParameterGroupError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteClusterSecurityGroupError {
ClusterSecurityGroupNotFoundFault(String),
InvalidClusterSecurityGroupStateFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DeleteClusterSecurityGroupError {
pub fn from_response(res: BufferedHttpResponse) -> DeleteClusterSecurityGroupError {
{
let reader = EventReader::new(res.body.as_slice());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"ClusterSecurityGroupNotFound" => return DeleteClusterSecurityGroupError::ClusterSecurityGroupNotFoundFault(String::from(parsed_error.message)),"InvalidClusterSecurityGroupState" => return DeleteClusterSecurityGroupError::InvalidClusterSecurityGroupStateFault(String::from(parsed_error.message)),_ => {}
}
}
}
DeleteClusterSecurityGroupError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for DeleteClusterSecurityGroupError {
fn from(err: XmlParseError) -> DeleteClusterSecurityGroupError {
let XmlParseError(message) = err;
DeleteClusterSecurityGroupError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DeleteClusterSecurityGroupError {
fn from(err: CredentialsError) -> DeleteClusterSecurityGroupError {
DeleteClusterSecurityGroupError::Credentials(err)
}
}
impl From<HttpDispatchError> for DeleteClusterSecurityGroupError {
fn from(err: HttpDispatchError) -> DeleteClusterSecurityGroupError {
DeleteClusterSecurityGroupError::HttpDispatch(err)
}
}
impl From<io::Error> for DeleteClusterSecurityGroupError {
fn from(err: io::Error) -> DeleteClusterSecurityGroupError {
DeleteClusterSecurityGroupError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DeleteClusterSecurityGroupError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteClusterSecurityGroupError {
fn description(&self) -> &str {
match *self {
DeleteClusterSecurityGroupError::ClusterSecurityGroupNotFoundFault(ref cause) => cause,
DeleteClusterSecurityGroupError::InvalidClusterSecurityGroupStateFault(ref cause) => {
cause
}
DeleteClusterSecurityGroupError::Validation(ref cause) => cause,
DeleteClusterSecurityGroupError::Credentials(ref err) => err.description(),
DeleteClusterSecurityGroupError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DeleteClusterSecurityGroupError::ParseError(ref cause) => cause,
DeleteClusterSecurityGroupError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteClusterSnapshotError {
ClusterSnapshotNotFoundFault(String),
InvalidClusterSnapshotStateFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DeleteClusterSnapshotError {
pub fn from_response(res: BufferedHttpResponse) -> DeleteClusterSnapshotError {
{
let reader = EventReader::new(res.body.as_slice());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"ClusterSnapshotNotFound" => {
return DeleteClusterSnapshotError::ClusterSnapshotNotFoundFault(
String::from(parsed_error.message),
)
}
"InvalidClusterSnapshotState" => {
return DeleteClusterSnapshotError::InvalidClusterSnapshotStateFault(
String::from(parsed_error.message),
)
}
_ => {}
}
}
}
DeleteClusterSnapshotError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for DeleteClusterSnapshotError {
fn from(err: XmlParseError) -> DeleteClusterSnapshotError {
let XmlParseError(message) = err;
DeleteClusterSnapshotError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DeleteClusterSnapshotError {
fn from(err: CredentialsError) -> DeleteClusterSnapshotError {
DeleteClusterSnapshotError::Credentials(err)
}
}
impl From<HttpDispatchError> for DeleteClusterSnapshotError {
fn from(err: HttpDispatchError) -> DeleteClusterSnapshotError {
DeleteClusterSnapshotError::HttpDispatch(err)
}
}
impl From<io::Error> for DeleteClusterSnapshotError {
fn from(err: io::Error) -> DeleteClusterSnapshotError {
DeleteClusterSnapshotError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DeleteClusterSnapshotError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteClusterSnapshotError {
fn description(&self) -> &str {
match *self {
DeleteClusterSnapshotError::ClusterSnapshotNotFoundFault(ref cause) => cause,
DeleteClusterSnapshotError::InvalidClusterSnapshotStateFault(ref cause) => cause,
DeleteClusterSnapshotError::Validation(ref cause) => cause,
DeleteClusterSnapshotError::Credentials(ref err) => err.description(),
DeleteClusterSnapshotError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DeleteClusterSnapshotError::ParseError(ref cause) => cause,
DeleteClusterSnapshotError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteClusterSubnetGroupError {
ClusterSubnetGroupNotFoundFault(String),
InvalidClusterSubnetGroupStateFault(String),
InvalidClusterSubnetStateFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DeleteClusterSubnetGroupError {
pub fn from_response(res: BufferedHttpResponse) -> DeleteClusterSubnetGroupError {
{
let reader = EventReader::new(res.body.as_slice());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"ClusterSubnetGroupNotFoundFault" => {
return DeleteClusterSubnetGroupError::ClusterSubnetGroupNotFoundFault(
String::from(parsed_error.message),
)
}
"InvalidClusterSubnetGroupStateFault" => {
return DeleteClusterSubnetGroupError::InvalidClusterSubnetGroupStateFault(
String::from(parsed_error.message),
)
}
"InvalidClusterSubnetStateFault" => {
return DeleteClusterSubnetGroupError::InvalidClusterSubnetStateFault(
String::from(parsed_error.message),
)
}
_ => {}
}
}
}
DeleteClusterSubnetGroupError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for DeleteClusterSubnetGroupError {
fn from(err: XmlParseError) -> DeleteClusterSubnetGroupError {
let XmlParseError(message) = err;
DeleteClusterSubnetGroupError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DeleteClusterSubnetGroupError {
fn from(err: CredentialsError) -> DeleteClusterSubnetGroupError {
DeleteClusterSubnetGroupError::Credentials(err)
}
}
impl From<HttpDispatchError> for DeleteClusterSubnetGroupError {
fn from(err: HttpDispatchError) -> DeleteClusterSubnetGroupError {
DeleteClusterSubnetGroupError::HttpDispatch(err)
}
}
impl From<io::Error> for DeleteClusterSubnetGroupError {
fn from(err: io::Error) -> DeleteClusterSubnetGroupError {
DeleteClusterSubnetGroupError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DeleteClusterSubnetGroupError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteClusterSubnetGroupError {
fn description(&self) -> &str {
match *self {
DeleteClusterSubnetGroupError::ClusterSubnetGroupNotFoundFault(ref cause) => cause,
DeleteClusterSubnetGroupError::InvalidClusterSubnetGroupStateFault(ref cause) => cause,
DeleteClusterSubnetGroupError::InvalidClusterSubnetStateFault(ref cause) => cause,
DeleteClusterSubnetGroupError::Validation(ref cause) => cause,
DeleteClusterSubnetGroupError::Credentials(ref err) => err.description(),
DeleteClusterSubnetGroupError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DeleteClusterSubnetGroupError::ParseError(ref cause) => cause,
DeleteClusterSubnetGroupError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteEventSubscriptionError {
InvalidSubscriptionStateFault(String),
SubscriptionNotFoundFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DeleteEventSubscriptionError {
pub fn from_response(res: BufferedHttpResponse) -> DeleteEventSubscriptionError {
{
let reader = EventReader::new(res.body.as_slice());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"InvalidSubscriptionStateFault" => {
return DeleteEventSubscriptionError::InvalidSubscriptionStateFault(
String::from(parsed_error.message),
)
}
"SubscriptionNotFound" => {
return DeleteEventSubscriptionError::SubscriptionNotFoundFault(
String::from(parsed_error.message),
)
}
_ => {}
}
}
}
DeleteEventSubscriptionError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for DeleteEventSubscriptionError {
fn from(err: XmlParseError) -> DeleteEventSubscriptionError {
let XmlParseError(message) = err;
DeleteEventSubscriptionError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DeleteEventSubscriptionError {
fn from(err: CredentialsError) -> DeleteEventSubscriptionError {
DeleteEventSubscriptionError::Credentials(err)
}
}
impl From<HttpDispatchError> for DeleteEventSubscriptionError {
fn from(err: HttpDispatchError) -> DeleteEventSubscriptionError {
DeleteEventSubscriptionError::HttpDispatch(err)
}
}
impl From<io::Error> for DeleteEventSubscriptionError {
fn from(err: io::Error) -> DeleteEventSubscriptionError {
DeleteEventSubscriptionError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DeleteEventSubscriptionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteEventSubscriptionError {
fn description(&self) -> &str {
match *self {
DeleteEventSubscriptionError::InvalidSubscriptionStateFault(ref cause) => cause,
DeleteEventSubscriptionError::SubscriptionNotFoundFault(ref cause) => cause,
DeleteEventSubscriptionError::Validation(ref cause) => cause,
DeleteEventSubscriptionError::Credentials(ref err) => err.description(),
DeleteEventSubscriptionError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DeleteEventSubscriptionError::ParseError(ref cause) => cause,
DeleteEventSubscriptionError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteHsmClientCertificateError {
HsmClientCertificateNotFoundFault(String),
InvalidHsmClientCertificateStateFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DeleteHsmClientCertificateError {
pub fn from_response(res: BufferedHttpResponse) -> DeleteHsmClientCertificateError {
{
let reader = EventReader::new(res.body.as_slice());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"HsmClientCertificateNotFoundFault" => return DeleteHsmClientCertificateError::HsmClientCertificateNotFoundFault(String::from(parsed_error.message)),"InvalidHsmClientCertificateStateFault" => return DeleteHsmClientCertificateError::InvalidHsmClientCertificateStateFault(String::from(parsed_error.message)),_ => {}
}
}
}
DeleteHsmClientCertificateError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for DeleteHsmClientCertificateError {
fn from(err: XmlParseError) -> DeleteHsmClientCertificateError {
let XmlParseError(message) = err;
DeleteHsmClientCertificateError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DeleteHsmClientCertificateError {
fn from(err: CredentialsError) -> DeleteHsmClientCertificateError {
DeleteHsmClientCertificateError::Credentials(err)
}
}
impl From<HttpDispatchError> for DeleteHsmClientCertificateError {
fn from(err: HttpDispatchError) -> DeleteHsmClientCertificateError {
DeleteHsmClientCertificateError::HttpDispatch(err)
}
}
impl From<io::Error> for DeleteHsmClientCertificateError {
fn from(err: io::Error) -> DeleteHsmClientCertificateError {
DeleteHsmClientCertificateError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DeleteHsmClientCertificateError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteHsmClientCertificateError {
fn description(&self) -> &str {
match *self {
DeleteHsmClientCertificateError::HsmClientCertificateNotFoundFault(ref cause) => cause,
DeleteHsmClientCertificateError::InvalidHsmClientCertificateStateFault(ref cause) => {
cause
}
DeleteHsmClientCertificateError::Validation(ref cause) => cause,
DeleteHsmClientCertificateError::Credentials(ref err) => err.description(),
DeleteHsmClientCertificateError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DeleteHsmClientCertificateError::ParseError(ref cause) => cause,
DeleteHsmClientCertificateError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteHsmConfigurationError {
HsmConfigurationNotFoundFault(String),
InvalidHsmConfigurationStateFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DeleteHsmConfigurationError {
pub fn from_response(res: BufferedHttpResponse) -> DeleteHsmConfigurationError {
{
let reader = EventReader::new(res.body.as_slice());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"HsmConfigurationNotFoundFault" => {
return DeleteHsmConfigurationError::HsmConfigurationNotFoundFault(
String::from(parsed_error.message),
)
}
"InvalidHsmConfigurationStateFault" => {
return DeleteHsmConfigurationError::InvalidHsmConfigurationStateFault(
String::from(parsed_error.message),
)
}
_ => {}
}
}
}
DeleteHsmConfigurationError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for DeleteHsmConfigurationError {
fn from(err: XmlParseError) -> DeleteHsmConfigurationError {
let XmlParseError(message) = err;
DeleteHsmConfigurationError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DeleteHsmConfigurationError {
fn from(err: CredentialsError) -> DeleteHsmConfigurationError {
DeleteHsmConfigurationError::Credentials(err)
}
}
impl From<HttpDispatchError> for DeleteHsmConfigurationError {
fn from(err: HttpDispatchError) -> DeleteHsmConfigurationError {
DeleteHsmConfigurationError::HttpDispatch(err)
}
}
impl From<io::Error> for DeleteHsmConfigurationError {
fn from(err: io::Error) -> DeleteHsmConfigurationError {
DeleteHsmConfigurationError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DeleteHsmConfigurationError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteHsmConfigurationError {
fn description(&self) -> &str {
match *self {
DeleteHsmConfigurationError::HsmConfigurationNotFoundFault(ref cause) => cause,
DeleteHsmConfigurationError::InvalidHsmConfigurationStateFault(ref cause) => cause,
DeleteHsmConfigurationError::Validation(ref cause) => cause,
DeleteHsmConfigurationError::Credentials(ref err) => err.description(),
DeleteHsmConfigurationError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DeleteHsmConfigurationError::ParseError(ref cause) => cause,
DeleteHsmConfigurationError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteSnapshotCopyGrantError {
InvalidSnapshotCopyGrantStateFault(String),
SnapshotCopyGrantNotFoundFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DeleteSnapshotCopyGrantError {
pub fn from_response(res: BufferedHttpResponse) -> DeleteSnapshotCopyGrantError {
{
let reader = EventReader::new(res.body.as_slice());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"InvalidSnapshotCopyGrantStateFault" => {
return DeleteSnapshotCopyGrantError::InvalidSnapshotCopyGrantStateFault(
String::from(parsed_error.message),
)
}
"SnapshotCopyGrantNotFoundFault" => {
return DeleteSnapshotCopyGrantError::SnapshotCopyGrantNotFoundFault(
String::from(parsed_error.message),
)
}
_ => {}
}
}
}
DeleteSnapshotCopyGrantError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for DeleteSnapshotCopyGrantError {
fn from(err: XmlParseError) -> DeleteSnapshotCopyGrantError {
let XmlParseError(message) = err;
DeleteSnapshotCopyGrantError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DeleteSnapshotCopyGrantError {
fn from(err: CredentialsError) -> DeleteSnapshotCopyGrantError {
DeleteSnapshotCopyGrantError::Credentials(err)
}
}
impl From<HttpDispatchError> for DeleteSnapshotCopyGrantError {
fn from(err: HttpDispatchError) -> DeleteSnapshotCopyGrantError {
DeleteSnapshotCopyGrantError::HttpDispatch(err)
}
}
impl From<io::Error> for DeleteSnapshotCopyGrantError {
fn from(err: io::Error) -> DeleteSnapshotCopyGrantError {
DeleteSnapshotCopyGrantError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DeleteSnapshotCopyGrantError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteSnapshotCopyGrantError {
fn description(&self) -> &str {
match *self {
DeleteSnapshotCopyGrantError::InvalidSnapshotCopyGrantStateFault(ref cause) => cause,
DeleteSnapshotCopyGrantError::SnapshotCopyGrantNotFoundFault(ref cause) => cause,
DeleteSnapshotCopyGrantError::Validation(ref cause) => cause,
DeleteSnapshotCopyGrantError::Credentials(ref err) => err.description(),
DeleteSnapshotCopyGrantError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DeleteSnapshotCopyGrantError::ParseError(ref cause) => cause,
DeleteSnapshotCopyGrantError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteTagsError {
InvalidTagFault(String),
ResourceNotFoundFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DeleteTagsError {
pub fn from_response(res: BufferedHttpResponse) -> DeleteTagsError {
{
let reader = EventReader::new(res.body.as_slice());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"InvalidTagFault" => {
return DeleteTagsError::InvalidTagFault(String::from(parsed_error.message))
}
"ResourceNotFoundFault" => {
return DeleteTagsError::ResourceNotFoundFault(String::from(
parsed_error.message,
))
}
_ => {}
}
}
}
DeleteTagsError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for DeleteTagsError {
fn from(err: XmlParseError) -> DeleteTagsError {
let XmlParseError(message) = err;
DeleteTagsError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DeleteTagsError {
fn from(err: CredentialsError) -> DeleteTagsError {
DeleteTagsError::Credentials(err)
}
}
impl From<HttpDispatchError> for DeleteTagsError {
fn from(err: HttpDispatchError) -> DeleteTagsError {
DeleteTagsError::HttpDispatch(err)
}
}
impl From<io::Error> for DeleteTagsError {
fn from(err: io::Error) -> DeleteTagsError {
DeleteTagsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DeleteTagsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteTagsError {
fn description(&self) -> &str {
match *self {
DeleteTagsError::InvalidTagFault(ref cause) => cause,
DeleteTagsError::ResourceNotFoundFault(ref cause) => cause,
DeleteTagsError::Validation(ref cause) => cause,
DeleteTagsError::Credentials(ref err) => err.description(),
DeleteTagsError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
DeleteTagsError::ParseError(ref cause) => cause,
DeleteTagsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeClusterDbRevisionsError {
ClusterNotFoundFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeClusterDbRevisionsError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeClusterDbRevisionsError {
{
let reader = EventReader::new(res.body.as_slice());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"ClusterNotFound" => {
return DescribeClusterDbRevisionsError::ClusterNotFoundFault(String::from(
parsed_error.message,
))
}
_ => {}
}
}
}
DescribeClusterDbRevisionsError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for DescribeClusterDbRevisionsError {
fn from(err: XmlParseError) -> DescribeClusterDbRevisionsError {
let XmlParseError(message) = err;
DescribeClusterDbRevisionsError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DescribeClusterDbRevisionsError {
fn from(err: CredentialsError) -> DescribeClusterDbRevisionsError {
DescribeClusterDbRevisionsError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeClusterDbRevisionsError {
fn from(err: HttpDispatchError) -> DescribeClusterDbRevisionsError {
DescribeClusterDbRevisionsError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeClusterDbRevisionsError {
fn from(err: io::Error) -> DescribeClusterDbRevisionsError {
DescribeClusterDbRevisionsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeClusterDbRevisionsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeClusterDbRevisionsError {
fn description(&self) -> &str {
match *self {
DescribeClusterDbRevisionsError::ClusterNotFoundFault(ref cause) => cause,
DescribeClusterDbRevisionsError::Validation(ref cause) => cause,
DescribeClusterDbRevisionsError::Credentials(ref err) => err.description(),
DescribeClusterDbRevisionsError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DescribeClusterDbRevisionsError::ParseError(ref cause) => cause,
DescribeClusterDbRevisionsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeClusterParameterGroupsError {
ClusterParameterGroupNotFoundFault(String),
InvalidTagFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeClusterParameterGroupsError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeClusterParameterGroupsError {
{
let reader = EventReader::new(res.body.as_slice());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"ClusterParameterGroupNotFound" => return DescribeClusterParameterGroupsError::ClusterParameterGroupNotFoundFault(String::from(parsed_error.message)),"InvalidTagFault" => return DescribeClusterParameterGroupsError::InvalidTagFault(String::from(parsed_error.message)),_ => {}
}
}
}
DescribeClusterParameterGroupsError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for DescribeClusterParameterGroupsError {
fn from(err: XmlParseError) -> DescribeClusterParameterGroupsError {
let XmlParseError(message) = err;
DescribeClusterParameterGroupsError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DescribeClusterParameterGroupsError {
fn from(err: CredentialsError) -> DescribeClusterParameterGroupsError {
DescribeClusterParameterGroupsError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeClusterParameterGroupsError {
fn from(err: HttpDispatchError) -> DescribeClusterParameterGroupsError {
DescribeClusterParameterGroupsError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeClusterParameterGroupsError {
fn from(err: io::Error) -> DescribeClusterParameterGroupsError {
DescribeClusterParameterGroupsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeClusterParameterGroupsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeClusterParameterGroupsError {
fn description(&self) -> &str {
match *self {
DescribeClusterParameterGroupsError::ClusterParameterGroupNotFoundFault(ref cause) => {
cause
}
DescribeClusterParameterGroupsError::InvalidTagFault(ref cause) => cause,
DescribeClusterParameterGroupsError::Validation(ref cause) => cause,
DescribeClusterParameterGroupsError::Credentials(ref err) => err.description(),
DescribeClusterParameterGroupsError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DescribeClusterParameterGroupsError::ParseError(ref cause) => cause,
DescribeClusterParameterGroupsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeClusterParametersError {
ClusterParameterGroupNotFoundFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeClusterParametersError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeClusterParametersError {
{
let reader = EventReader::new(res.body.as_slice());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"ClusterParameterGroupNotFound" => {
return DescribeClusterParametersError::ClusterParameterGroupNotFoundFault(
String::from(parsed_error.message),
)
}
_ => {}
}
}
}
DescribeClusterParametersError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for DescribeClusterParametersError {
fn from(err: XmlParseError) -> DescribeClusterParametersError {
let XmlParseError(message) = err;
DescribeClusterParametersError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DescribeClusterParametersError {
fn from(err: CredentialsError) -> DescribeClusterParametersError {
DescribeClusterParametersError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeClusterParametersError {
fn from(err: HttpDispatchError) -> DescribeClusterParametersError {
DescribeClusterParametersError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeClusterParametersError {
fn from(err: io::Error) -> DescribeClusterParametersError {
DescribeClusterParametersError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeClusterParametersError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeClusterParametersError {
fn description(&self) -> &str {
match *self {
DescribeClusterParametersError::ClusterParameterGroupNotFoundFault(ref cause) => cause,
DescribeClusterParametersError::Validation(ref cause) => cause,
DescribeClusterParametersError::Credentials(ref err) => err.description(),
DescribeClusterParametersError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DescribeClusterParametersError::ParseError(ref cause) => cause,
DescribeClusterParametersError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeClusterSecurityGroupsError {
ClusterSecurityGroupNotFoundFault(String),
InvalidTagFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeClusterSecurityGroupsError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeClusterSecurityGroupsError {
{
let reader = EventReader::new(res.body.as_slice());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"ClusterSecurityGroupNotFound" => {
return DescribeClusterSecurityGroupsError::ClusterSecurityGroupNotFoundFault(
String::from(parsed_error.message),
)
}
"InvalidTagFault" => {
return DescribeClusterSecurityGroupsError::InvalidTagFault(String::from(
parsed_error.message,
))
}
_ => {}
}
}
}
DescribeClusterSecurityGroupsError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for DescribeClusterSecurityGroupsError {
fn from(err: XmlParseError) -> DescribeClusterSecurityGroupsError {
let XmlParseError(message) = err;
DescribeClusterSecurityGroupsError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DescribeClusterSecurityGroupsError {
fn from(err: CredentialsError) -> DescribeClusterSecurityGroupsError {
DescribeClusterSecurityGroupsError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeClusterSecurityGroupsError {
fn from(err: HttpDispatchError) -> DescribeClusterSecurityGroupsError {
DescribeClusterSecurityGroupsError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeClusterSecurityGroupsError {
fn from(err: io::Error) -> DescribeClusterSecurityGroupsError {
DescribeClusterSecurityGroupsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeClusterSecurityGroupsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeClusterSecurityGroupsError {
fn description(&self) -> &str {
match *self {
DescribeClusterSecurityGroupsError::ClusterSecurityGroupNotFoundFault(ref cause) => {
cause
}
DescribeClusterSecurityGroupsError::InvalidTagFault(ref cause) => cause,
DescribeClusterSecurityGroupsError::Validation(ref cause) => cause,
DescribeClusterSecurityGroupsError::Credentials(ref err) => err.description(),
DescribeClusterSecurityGroupsError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DescribeClusterSecurityGroupsError::ParseError(ref cause) => cause,
DescribeClusterSecurityGroupsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeClusterSnapshotsError {
ClusterNotFoundFault(String),
ClusterSnapshotNotFoundFault(String),
InvalidTagFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeClusterSnapshotsError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeClusterSnapshotsError {
{
let reader = EventReader::new(res.body.as_slice());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"ClusterNotFound" => {
return DescribeClusterSnapshotsError::ClusterNotFoundFault(String::from(
parsed_error.message,
))
}
"ClusterSnapshotNotFound" => {
return DescribeClusterSnapshotsError::ClusterSnapshotNotFoundFault(
String::from(parsed_error.message),
)
}
"InvalidTagFault" => {
return DescribeClusterSnapshotsError::InvalidTagFault(String::from(
parsed_error.message,
))
}
_ => {}
}
}
}
DescribeClusterSnapshotsError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for DescribeClusterSnapshotsError {
fn from(err: XmlParseError) -> DescribeClusterSnapshotsError {
let XmlParseError(message) = err;
DescribeClusterSnapshotsError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DescribeClusterSnapshotsError {
fn from(err: CredentialsError) -> DescribeClusterSnapshotsError {
DescribeClusterSnapshotsError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeClusterSnapshotsError {
fn from(err: HttpDispatchError) -> DescribeClusterSnapshotsError {
DescribeClusterSnapshotsError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeClusterSnapshotsError {
fn from(err: io::Error) -> DescribeClusterSnapshotsError {
DescribeClusterSnapshotsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeClusterSnapshotsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeClusterSnapshotsError {
fn description(&self) -> &str {
match *self {
DescribeClusterSnapshotsError::ClusterNotFoundFault(ref cause) => cause,
DescribeClusterSnapshotsError::ClusterSnapshotNotFoundFault(ref cause) => cause,
DescribeClusterSnapshotsError::InvalidTagFault(ref cause) => cause,
DescribeClusterSnapshotsError::Validation(ref cause) => cause,
DescribeClusterSnapshotsError::Credentials(ref err) => err.description(),
DescribeClusterSnapshotsError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DescribeClusterSnapshotsError::ParseError(ref cause) => cause,
DescribeClusterSnapshotsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeClusterSubnetGroupsError {
ClusterSubnetGroupNotFoundFault(String),
InvalidTagFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeClusterSubnetGroupsError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeClusterSubnetGroupsError {
{
let reader = EventReader::new(res.body.as_slice());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"ClusterSubnetGroupNotFoundFault" => {
return DescribeClusterSubnetGroupsError::ClusterSubnetGroupNotFoundFault(
String::from(parsed_error.message),
)
}
"InvalidTagFault" => {
return DescribeClusterSubnetGroupsError::InvalidTagFault(String::from(
parsed_error.message,
))
}
_ => {}
}
}
}
DescribeClusterSubnetGroupsError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for DescribeClusterSubnetGroupsError {
fn from(err: XmlParseError) -> DescribeClusterSubnetGroupsError {
let XmlParseError(message) = err;
DescribeClusterSubnetGroupsError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DescribeClusterSubnetGroupsError {
fn from(err: CredentialsError) -> DescribeClusterSubnetGroupsError {
DescribeClusterSubnetGroupsError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeClusterSubnetGroupsError {
fn from(err: HttpDispatchError) -> DescribeClusterSubnetGroupsError {
DescribeClusterSubnetGroupsError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeClusterSubnetGroupsError {
fn from(err: io::Error) -> DescribeClusterSubnetGroupsError {
DescribeClusterSubnetGroupsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeClusterSubnetGroupsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeClusterSubnetGroupsError {
fn description(&self) -> &str {
match *self {
DescribeClusterSubnetGroupsError::ClusterSubnetGroupNotFoundFault(ref cause) => cause,
DescribeClusterSubnetGroupsError::InvalidTagFault(ref cause) => cause,
DescribeClusterSubnetGroupsError::Validation(ref cause) => cause,
DescribeClusterSubnetGroupsError::Credentials(ref err) => err.description(),
DescribeClusterSubnetGroupsError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DescribeClusterSubnetGroupsError::ParseError(ref cause) => cause,
DescribeClusterSubnetGroupsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeClusterTracksError {
InvalidClusterTrackFault(String),
UnauthorizedOperation(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeClusterTracksError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeClusterTracksError {
{
let reader = EventReader::new(res.body.as_slice());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"InvalidClusterTrack" => {
return DescribeClusterTracksError::InvalidClusterTrackFault(String::from(
parsed_error.message,
))
}
"UnauthorizedOperation" => {
return DescribeClusterTracksError::UnauthorizedOperation(String::from(
parsed_error.message,
))
}
_ => {}
}
}
}
DescribeClusterTracksError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for DescribeClusterTracksError {
fn from(err: XmlParseError) -> DescribeClusterTracksError {
let XmlParseError(message) = err;
DescribeClusterTracksError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DescribeClusterTracksError {
fn from(err: CredentialsError) -> DescribeClusterTracksError {
DescribeClusterTracksError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeClusterTracksError {
fn from(err: HttpDispatchError) -> DescribeClusterTracksError {
DescribeClusterTracksError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeClusterTracksError {
fn from(err: io::Error) -> DescribeClusterTracksError {
DescribeClusterTracksError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeClusterTracksError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeClusterTracksError {
fn description(&self) -> &str {
match *self {
DescribeClusterTracksError::InvalidClusterTrackFault(ref cause) => cause,
DescribeClusterTracksError::UnauthorizedOperation(ref cause) => cause,
DescribeClusterTracksError::Validation(ref cause) => cause,
DescribeClusterTracksError::Credentials(ref err) => err.description(),
DescribeClusterTracksError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DescribeClusterTracksError::ParseError(ref cause) => cause,
DescribeClusterTracksError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeClusterVersionsError {
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeClusterVersionsError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeClusterVersionsError {
{
let reader = EventReader::new(res.body.as_slice());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
DescribeClusterVersionsError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for DescribeClusterVersionsError {
fn from(err: XmlParseError) -> DescribeClusterVersionsError {
let XmlParseError(message) = err;
DescribeClusterVersionsError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DescribeClusterVersionsError {
fn from(err: CredentialsError) -> DescribeClusterVersionsError {
DescribeClusterVersionsError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeClusterVersionsError {
fn from(err: HttpDispatchError) -> DescribeClusterVersionsError {
DescribeClusterVersionsError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeClusterVersionsError {
fn from(err: io::Error) -> DescribeClusterVersionsError {
DescribeClusterVersionsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeClusterVersionsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeClusterVersionsError {
fn description(&self) -> &str {
match *self {
DescribeClusterVersionsError::Validation(ref cause) => cause,
DescribeClusterVersionsError::Credentials(ref err) => err.description(),
DescribeClusterVersionsError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DescribeClusterVersionsError::ParseError(ref cause) => cause,
DescribeClusterVersionsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeClustersError {
ClusterNotFoundFault(String),
InvalidTagFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeClustersError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeClustersError {
{
let reader = EventReader::new(res.body.as_slice());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"ClusterNotFound" => {
return DescribeClustersError::ClusterNotFoundFault(String::from(
parsed_error.message,
))
}
"InvalidTagFault" => {
return DescribeClustersError::InvalidTagFault(String::from(
parsed_error.message,
))
}
_ => {}
}
}
}
DescribeClustersError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for DescribeClustersError {
fn from(err: XmlParseError) -> DescribeClustersError {
let XmlParseError(message) = err;
DescribeClustersError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DescribeClustersError {
fn from(err: CredentialsError) -> DescribeClustersError {
DescribeClustersError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeClustersError {
fn from(err: HttpDispatchError) -> DescribeClustersError {
DescribeClustersError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeClustersError {
fn from(err: io::Error) -> DescribeClustersError {
DescribeClustersError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeClustersError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeClustersError {
fn description(&self) -> &str {
match *self {
DescribeClustersError::ClusterNotFoundFault(ref cause) => cause,
DescribeClustersError::InvalidTagFault(ref cause) => cause,
DescribeClustersError::Validation(ref cause) => cause,
DescribeClustersError::Credentials(ref err) => err.description(),
DescribeClustersError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
DescribeClustersError::ParseError(ref cause) => cause,
DescribeClustersError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeDefaultClusterParametersError {
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeDefaultClusterParametersError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeDefaultClusterParametersError {
{
let reader = EventReader::new(res.body.as_slice());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
DescribeDefaultClusterParametersError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for DescribeDefaultClusterParametersError {
fn from(err: XmlParseError) -> DescribeDefaultClusterParametersError {
let XmlParseError(message) = err;
DescribeDefaultClusterParametersError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DescribeDefaultClusterParametersError {
fn from(err: CredentialsError) -> DescribeDefaultClusterParametersError {
DescribeDefaultClusterParametersError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeDefaultClusterParametersError {
fn from(err: HttpDispatchError) -> DescribeDefaultClusterParametersError {
DescribeDefaultClusterParametersError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeDefaultClusterParametersError {
fn from(err: io::Error) -> DescribeDefaultClusterParametersError {
DescribeDefaultClusterParametersError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeDefaultClusterParametersError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeDefaultClusterParametersError {
fn description(&self) -> &str {
match *self {
DescribeDefaultClusterParametersError::Validation(ref cause) => cause,
DescribeDefaultClusterParametersError::Credentials(ref err) => err.description(),
DescribeDefaultClusterParametersError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DescribeDefaultClusterParametersError::ParseError(ref cause) => cause,
DescribeDefaultClusterParametersError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeEventCategoriesError {
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeEventCategoriesError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeEventCategoriesError {
{
let reader = EventReader::new(res.body.as_slice());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
DescribeEventCategoriesError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for DescribeEventCategoriesError {
fn from(err: XmlParseError) -> DescribeEventCategoriesError {
let XmlParseError(message) = err;
DescribeEventCategoriesError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DescribeEventCategoriesError {
fn from(err: CredentialsError) -> DescribeEventCategoriesError {
DescribeEventCategoriesError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeEventCategoriesError {
fn from(err: HttpDispatchError) -> DescribeEventCategoriesError {
DescribeEventCategoriesError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeEventCategoriesError {
fn from(err: io::Error) -> DescribeEventCategoriesError {
DescribeEventCategoriesError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeEventCategoriesError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeEventCategoriesError {
fn description(&self) -> &str {
match *self {
DescribeEventCategoriesError::Validation(ref cause) => cause,
DescribeEventCategoriesError::Credentials(ref err) => err.description(),
DescribeEventCategoriesError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DescribeEventCategoriesError::ParseError(ref cause) => cause,
DescribeEventCategoriesError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeEventSubscriptionsError {
InvalidTagFault(String),
SubscriptionNotFoundFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeEventSubscriptionsError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeEventSubscriptionsError {
{
let reader = EventReader::new(res.body.as_slice());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"InvalidTagFault" => {
return DescribeEventSubscriptionsError::InvalidTagFault(String::from(
parsed_error.message,
))
}
"SubscriptionNotFound" => {
return DescribeEventSubscriptionsError::SubscriptionNotFoundFault(
String::from(parsed_error.message),
)
}
_ => {}
}
}
}
DescribeEventSubscriptionsError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for DescribeEventSubscriptionsError {
fn from(err: XmlParseError) -> DescribeEventSubscriptionsError {
let XmlParseError(message) = err;
DescribeEventSubscriptionsError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DescribeEventSubscriptionsError {
fn from(err: CredentialsError) -> DescribeEventSubscriptionsError {
DescribeEventSubscriptionsError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeEventSubscriptionsError {
fn from(err: HttpDispatchError) -> DescribeEventSubscriptionsError {
DescribeEventSubscriptionsError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeEventSubscriptionsError {
fn from(err: io::Error) -> DescribeEventSubscriptionsError {
DescribeEventSubscriptionsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeEventSubscriptionsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeEventSubscriptionsError {
fn description(&self) -> &str {
match *self {
DescribeEventSubscriptionsError::InvalidTagFault(ref cause) => cause,
DescribeEventSubscriptionsError::SubscriptionNotFoundFault(ref cause) => cause,
DescribeEventSubscriptionsError::Validation(ref cause) => cause,
DescribeEventSubscriptionsError::Credentials(ref err) => err.description(),
DescribeEventSubscriptionsError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DescribeEventSubscriptionsError::ParseError(ref cause) => cause,
DescribeEventSubscriptionsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeEventsError {
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeEventsError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeEventsError {
{
let reader = EventReader::new(res.body.as_slice());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
DescribeEventsError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for DescribeEventsError {
fn from(err: XmlParseError) -> DescribeEventsError {
let XmlParseError(message) = err;
DescribeEventsError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DescribeEventsError {
fn from(err: CredentialsError) -> DescribeEventsError {
DescribeEventsError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeEventsError {
fn from(err: HttpDispatchError) -> DescribeEventsError {
DescribeEventsError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeEventsError {
fn from(err: io::Error) -> DescribeEventsError {
DescribeEventsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeEventsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeEventsError {
fn description(&self) -> &str {
match *self {
DescribeEventsError::Validation(ref cause) => cause,
DescribeEventsError::Credentials(ref err) => err.description(),
DescribeEventsError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
DescribeEventsError::ParseError(ref cause) => cause,
DescribeEventsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeHsmClientCertificatesError {
HsmClientCertificateNotFoundFault(String),
InvalidTagFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeHsmClientCertificatesError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeHsmClientCertificatesError {
{
let reader = EventReader::new(res.body.as_slice());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"HsmClientCertificateNotFoundFault" => {
return DescribeHsmClientCertificatesError::HsmClientCertificateNotFoundFault(
String::from(parsed_error.message),
)
}
"InvalidTagFault" => {
return DescribeHsmClientCertificatesError::InvalidTagFault(String::from(
parsed_error.message,
))
}
_ => {}
}
}
}
DescribeHsmClientCertificatesError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for DescribeHsmClientCertificatesError {
fn from(err: XmlParseError) -> DescribeHsmClientCertificatesError {
let XmlParseError(message) = err;
DescribeHsmClientCertificatesError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DescribeHsmClientCertificatesError {
fn from(err: CredentialsError) -> DescribeHsmClientCertificatesError {
DescribeHsmClientCertificatesError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeHsmClientCertificatesError {
fn from(err: HttpDispatchError) -> DescribeHsmClientCertificatesError {
DescribeHsmClientCertificatesError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeHsmClientCertificatesError {
fn from(err: io::Error) -> DescribeHsmClientCertificatesError {
DescribeHsmClientCertificatesError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeHsmClientCertificatesError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeHsmClientCertificatesError {
fn description(&self) -> &str {
match *self {
DescribeHsmClientCertificatesError::HsmClientCertificateNotFoundFault(ref cause) => {
cause
}
DescribeHsmClientCertificatesError::InvalidTagFault(ref cause) => cause,
DescribeHsmClientCertificatesError::Validation(ref cause) => cause,
DescribeHsmClientCertificatesError::Credentials(ref err) => err.description(),
DescribeHsmClientCertificatesError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DescribeHsmClientCertificatesError::ParseError(ref cause) => cause,
DescribeHsmClientCertificatesError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeHsmConfigurationsError {
HsmConfigurationNotFoundFault(String),
InvalidTagFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeHsmConfigurationsError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeHsmConfigurationsError {
{
let reader = EventReader::new(res.body.as_slice());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"HsmConfigurationNotFoundFault" => {
return DescribeHsmConfigurationsError::HsmConfigurationNotFoundFault(
String::from(parsed_error.message),
)
}
"InvalidTagFault" => {
return DescribeHsmConfigurationsError::InvalidTagFault(String::from(
parsed_error.message,
))
}
_ => {}
}
}
}
DescribeHsmConfigurationsError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for DescribeHsmConfigurationsError {
fn from(err: XmlParseError) -> DescribeHsmConfigurationsError {
let XmlParseError(message) = err;
DescribeHsmConfigurationsError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DescribeHsmConfigurationsError {
fn from(err: CredentialsError) -> DescribeHsmConfigurationsError {
DescribeHsmConfigurationsError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeHsmConfigurationsError {
fn from(err: HttpDispatchError) -> DescribeHsmConfigurationsError {
DescribeHsmConfigurationsError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeHsmConfigurationsError {
fn from(err: io::Error) -> DescribeHsmConfigurationsError {
DescribeHsmConfigurationsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeHsmConfigurationsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeHsmConfigurationsError {
fn description(&self) -> &str {
match *self {
DescribeHsmConfigurationsError::HsmConfigurationNotFoundFault(ref cause) => cause,
DescribeHsmConfigurationsError::InvalidTagFault(ref cause) => cause,
DescribeHsmConfigurationsError::Validation(ref cause) => cause,
DescribeHsmConfigurationsError::Credentials(ref err) => err.description(),
DescribeHsmConfigurationsError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DescribeHsmConfigurationsError::ParseError(ref cause) => cause,
DescribeHsmConfigurationsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeLoggingStatusError {
ClusterNotFoundFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeLoggingStatusError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeLoggingStatusError {
{
let reader = EventReader::new(res.body.as_slice());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"ClusterNotFound" => {
return DescribeLoggingStatusError::ClusterNotFoundFault(String::from(
parsed_error.message,
))
}
_ => {}
}
}
}
DescribeLoggingStatusError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for DescribeLoggingStatusError {
fn from(err: XmlParseError) -> DescribeLoggingStatusError {
let XmlParseError(message) = err;
DescribeLoggingStatusError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DescribeLoggingStatusError {
fn from(err: CredentialsError) -> DescribeLoggingStatusError {
DescribeLoggingStatusError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeLoggingStatusError {
fn from(err: HttpDispatchError) -> DescribeLoggingStatusError {
DescribeLoggingStatusError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeLoggingStatusError {
fn from(err: io::Error) -> DescribeLoggingStatusError {
DescribeLoggingStatusError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeLoggingStatusError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeLoggingStatusError {
fn description(&self) -> &str {
match *self {
DescribeLoggingStatusError::ClusterNotFoundFault(ref cause) => cause,
DescribeLoggingStatusError::Validation(ref cause) => cause,
DescribeLoggingStatusError::Credentials(ref err) => err.description(),
DescribeLoggingStatusError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DescribeLoggingStatusError::ParseError(ref cause) => cause,
DescribeLoggingStatusError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeOrderableClusterOptionsError {
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeOrderableClusterOptionsError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeOrderableClusterOptionsError {
{
let reader = EventReader::new(res.body.as_slice());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
DescribeOrderableClusterOptionsError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for DescribeOrderableClusterOptionsError {
fn from(err: XmlParseError) -> DescribeOrderableClusterOptionsError {
let XmlParseError(message) = err;
DescribeOrderableClusterOptionsError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DescribeOrderableClusterOptionsError {
fn from(err: CredentialsError) -> DescribeOrderableClusterOptionsError {
DescribeOrderableClusterOptionsError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeOrderableClusterOptionsError {
fn from(err: HttpDispatchError) -> DescribeOrderableClusterOptionsError {
DescribeOrderableClusterOptionsError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeOrderableClusterOptionsError {
fn from(err: io::Error) -> DescribeOrderableClusterOptionsError {
DescribeOrderableClusterOptionsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeOrderableClusterOptionsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeOrderableClusterOptionsError {
fn description(&self) -> &str {
match *self {
DescribeOrderableClusterOptionsError::Validation(ref cause) => cause,
DescribeOrderableClusterOptionsError::Credentials(ref err) => err.description(),
DescribeOrderableClusterOptionsError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DescribeOrderableClusterOptionsError::ParseError(ref cause) => cause,
DescribeOrderableClusterOptionsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeReservedNodeOfferingsError {
DependentServiceUnavailableFault(String),
ReservedNodeOfferingNotFoundFault(String),
UnsupportedOperationFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeReservedNodeOfferingsError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeReservedNodeOfferingsError {
{
let reader = EventReader::new(res.body.as_slice());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"DependentServiceUnavailableFault" => {
return DescribeReservedNodeOfferingsError::DependentServiceUnavailableFault(
String::from(parsed_error.message),
)
}
"ReservedNodeOfferingNotFound" => {
return DescribeReservedNodeOfferingsError::ReservedNodeOfferingNotFoundFault(
String::from(parsed_error.message),
)
}
"UnsupportedOperation" => {
return DescribeReservedNodeOfferingsError::UnsupportedOperationFault(
String::from(parsed_error.message),
)
}
_ => {}
}
}
}
DescribeReservedNodeOfferingsError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for DescribeReservedNodeOfferingsError {
fn from(err: XmlParseError) -> DescribeReservedNodeOfferingsError {
let XmlParseError(message) = err;
DescribeReservedNodeOfferingsError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DescribeReservedNodeOfferingsError {
fn from(err: CredentialsError) -> DescribeReservedNodeOfferingsError {
DescribeReservedNodeOfferingsError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeReservedNodeOfferingsError {
fn from(err: HttpDispatchError) -> DescribeReservedNodeOfferingsError {
DescribeReservedNodeOfferingsError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeReservedNodeOfferingsError {
fn from(err: io::Error) -> DescribeReservedNodeOfferingsError {
DescribeReservedNodeOfferingsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeReservedNodeOfferingsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeReservedNodeOfferingsError {
fn description(&self) -> &str {
match *self {
DescribeReservedNodeOfferingsError::DependentServiceUnavailableFault(ref cause) => {
cause
}
DescribeReservedNodeOfferingsError::ReservedNodeOfferingNotFoundFault(ref cause) => {
cause
}
DescribeReservedNodeOfferingsError::UnsupportedOperationFault(ref cause) => cause,
DescribeReservedNodeOfferingsError::Validation(ref cause) => cause,
DescribeReservedNodeOfferingsError::Credentials(ref err) => err.description(),
DescribeReservedNodeOfferingsError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DescribeReservedNodeOfferingsError::ParseError(ref cause) => cause,
DescribeReservedNodeOfferingsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeReservedNodesError {
DependentServiceUnavailableFault(String),
ReservedNodeNotFoundFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeReservedNodesError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeReservedNodesError {
{
let reader = EventReader::new(res.body.as_slice());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"DependentServiceUnavailableFault" => {
return DescribeReservedNodesError::DependentServiceUnavailableFault(
String::from(parsed_error.message),
)
}
"ReservedNodeNotFound" => {
return DescribeReservedNodesError::ReservedNodeNotFoundFault(String::from(
parsed_error.message,
))
}
_ => {}
}
}
}
DescribeReservedNodesError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for DescribeReservedNodesError {
fn from(err: XmlParseError) -> DescribeReservedNodesError {
let XmlParseError(message) = err;
DescribeReservedNodesError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DescribeReservedNodesError {
fn from(err: CredentialsError) -> DescribeReservedNodesError {
DescribeReservedNodesError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeReservedNodesError {
fn from(err: HttpDispatchError) -> DescribeReservedNodesError {
DescribeReservedNodesError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeReservedNodesError {
fn from(err: io::Error) -> DescribeReservedNodesError {
DescribeReservedNodesError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeReservedNodesError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeReservedNodesError {
fn description(&self) -> &str {
match *self {
DescribeReservedNodesError::DependentServiceUnavailableFault(ref cause) => cause,
DescribeReservedNodesError::ReservedNodeNotFoundFault(ref cause) => cause,
DescribeReservedNodesError::Validation(ref cause) => cause,
DescribeReservedNodesError::Credentials(ref err) => err.description(),
DescribeReservedNodesError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DescribeReservedNodesError::ParseError(ref cause) => cause,
DescribeReservedNodesError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeResizeError {
ClusterNotFoundFault(String),
ResizeNotFoundFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeResizeError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeResizeError {
{
let reader = EventReader::new(res.body.as_slice());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"ClusterNotFound" => {
return DescribeResizeError::ClusterNotFoundFault(String::from(
parsed_error.message,
))
}
"ResizeNotFound" => {
return DescribeResizeError::ResizeNotFoundFault(String::from(
parsed_error.message,
))
}
_ => {}
}
}
}
DescribeResizeError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for DescribeResizeError {
fn from(err: XmlParseError) -> DescribeResizeError {
let XmlParseError(message) = err;
DescribeResizeError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DescribeResizeError {
fn from(err: CredentialsError) -> DescribeResizeError {
DescribeResizeError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeResizeError {
fn from(err: HttpDispatchError) -> DescribeResizeError {
DescribeResizeError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeResizeError {
fn from(err: io::Error) -> DescribeResizeError {
DescribeResizeError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeResizeError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeResizeError {
fn description(&self) -> &str {
match *self {
DescribeResizeError::ClusterNotFoundFault(ref cause) => cause,
DescribeResizeError::ResizeNotFoundFault(ref cause) => cause,
DescribeResizeError::Validation(ref cause) => cause,
DescribeResizeError::Credentials(ref err) => err.description(),
DescribeResizeError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
DescribeResizeError::ParseError(ref cause) => cause,
DescribeResizeError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeSnapshotCopyGrantsError {
InvalidTagFault(String),
SnapshotCopyGrantNotFoundFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeSnapshotCopyGrantsError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeSnapshotCopyGrantsError {
{
let reader = EventReader::new(res.body.as_slice());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"InvalidTagFault" => {
return DescribeSnapshotCopyGrantsError::InvalidTagFault(String::from(
parsed_error.message,
))
}
"SnapshotCopyGrantNotFoundFault" => {
return DescribeSnapshotCopyGrantsError::SnapshotCopyGrantNotFoundFault(
String::from(parsed_error.message),
)
}
_ => {}
}
}
}
DescribeSnapshotCopyGrantsError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for DescribeSnapshotCopyGrantsError {
fn from(err: XmlParseError) -> DescribeSnapshotCopyGrantsError {
let XmlParseError(message) = err;
DescribeSnapshotCopyGrantsError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DescribeSnapshotCopyGrantsError {
fn from(err: CredentialsError) -> DescribeSnapshotCopyGrantsError {
DescribeSnapshotCopyGrantsError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeSnapshotCopyGrantsError {
fn from(err: HttpDispatchError) -> DescribeSnapshotCopyGrantsError {
DescribeSnapshotCopyGrantsError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeSnapshotCopyGrantsError {
fn from(err: io::Error) -> DescribeSnapshotCopyGrantsError {
DescribeSnapshotCopyGrantsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeSnapshotCopyGrantsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeSnapshotCopyGrantsError {
fn description(&self) -> &str {
match *self {
DescribeSnapshotCopyGrantsError::InvalidTagFault(ref cause) => cause,
DescribeSnapshotCopyGrantsError::SnapshotCopyGrantNotFoundFault(ref cause) => cause,
DescribeSnapshotCopyGrantsError::Validation(ref cause) => cause,
DescribeSnapshotCopyGrantsError::Credentials(ref err) => err.description(),
DescribeSnapshotCopyGrantsError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DescribeSnapshotCopyGrantsError::ParseError(ref cause) => cause,
DescribeSnapshotCopyGrantsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeTableRestoreStatusError {
ClusterNotFoundFault(String),
TableRestoreNotFoundFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeTableRestoreStatusError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeTableRestoreStatusError {
{
let reader = EventReader::new(res.body.as_slice());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"ClusterNotFound" => {
return DescribeTableRestoreStatusError::ClusterNotFoundFault(String::from(
parsed_error.message,
))
}
"TableRestoreNotFoundFault" => {
return DescribeTableRestoreStatusError::TableRestoreNotFoundFault(
String::from(parsed_error.message),
)
}
_ => {}
}
}
}
DescribeTableRestoreStatusError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for DescribeTableRestoreStatusError {
fn from(err: XmlParseError) -> DescribeTableRestoreStatusError {
let XmlParseError(message) = err;
DescribeTableRestoreStatusError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DescribeTableRestoreStatusError {
fn from(err: CredentialsError) -> DescribeTableRestoreStatusError {
DescribeTableRestoreStatusError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeTableRestoreStatusError {
fn from(err: HttpDispatchError) -> DescribeTableRestoreStatusError {
DescribeTableRestoreStatusError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeTableRestoreStatusError {
fn from(err: io::Error) -> DescribeTableRestoreStatusError {
DescribeTableRestoreStatusError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeTableRestoreStatusError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeTableRestoreStatusError {
fn description(&self) -> &str {
match *self {
DescribeTableRestoreStatusError::ClusterNotFoundFault(ref cause) => cause,
DescribeTableRestoreStatusError::TableRestoreNotFoundFault(ref cause) => cause,
DescribeTableRestoreStatusError::Validation(ref cause) => cause,
DescribeTableRestoreStatusError::Credentials(ref err) => err.description(),
DescribeTableRestoreStatusError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DescribeTableRestoreStatusError::ParseError(ref cause) => cause,
DescribeTableRestoreStatusError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeTagsError {
InvalidTagFault(String),
ResourceNotFoundFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeTagsError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeTagsError {
{
let reader = EventReader::new(res.body.as_slice());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"InvalidTagFault" => {
return DescribeTagsError::InvalidTagFault(String::from(
parsed_error.message,
))
}
"ResourceNotFoundFault" => {
return DescribeTagsError::ResourceNotFoundFault(String::from(
parsed_error.message,
))
}
_ => {}
}
}
}
DescribeTagsError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for DescribeTagsError {
fn from(err: XmlParseError) -> DescribeTagsError {
let XmlParseError(message) = err;
DescribeTagsError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DescribeTagsError {
fn from(err: CredentialsError) -> DescribeTagsError {
DescribeTagsError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeTagsError {
fn from(err: HttpDispatchError) -> DescribeTagsError {
DescribeTagsError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeTagsError {
fn from(err: io::Error) -> DescribeTagsError {
DescribeTagsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeTagsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeTagsError {
fn description(&self) -> &str {
match *self {
DescribeTagsError::InvalidTagFault(ref cause) => cause,
DescribeTagsError::ResourceNotFoundFault(ref cause) => cause,
DescribeTagsError::Validation(ref cause) => cause,
DescribeTagsError::Credentials(ref err) => err.description(),
DescribeTagsError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
DescribeTagsError::ParseError(ref cause) => cause,
DescribeTagsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DisableLoggingError {
ClusterNotFoundFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DisableLoggingError {
pub fn from_response(res: BufferedHttpResponse) -> DisableLoggingError {
{
let reader = EventReader::new(res.body.as_slice());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"ClusterNotFound" => {
return DisableLoggingError::ClusterNotFoundFault(String::from(
parsed_error.message,
))
}
_ => {}
}
}
}
DisableLoggingError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for DisableLoggingError {
fn from(err: XmlParseError) -> DisableLoggingError {
let XmlParseError(message) = err;
DisableLoggingError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DisableLoggingError {
fn from(err: CredentialsError) -> DisableLoggingError {
DisableLoggingError::Credentials(err)
}
}
impl From<HttpDispatchError> for DisableLoggingError {
fn from(err: HttpDispatchError) -> DisableLoggingError {
DisableLoggingError::HttpDispatch(err)
}
}
impl From<io::Error> for DisableLoggingError {
fn from(err: io::Error) -> DisableLoggingError {
DisableLoggingError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DisableLoggingError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DisableLoggingError {
fn description(&self) -> &str {
match *self {
DisableLoggingError::ClusterNotFoundFault(ref cause) => cause,
DisableLoggingError::Validation(ref cause) => cause,
DisableLoggingError::Credentials(ref err) => err.description(),
DisableLoggingError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
DisableLoggingError::ParseError(ref cause) => cause,
DisableLoggingError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DisableSnapshotCopyError {
ClusterNotFoundFault(String),
InvalidClusterStateFault(String),
SnapshotCopyAlreadyDisabledFault(String),
UnauthorizedOperation(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DisableSnapshotCopyError {
pub fn from_response(res: BufferedHttpResponse) -> DisableSnapshotCopyError {
{
let reader = EventReader::new(res.body.as_slice());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"ClusterNotFound" => {
return DisableSnapshotCopyError::ClusterNotFoundFault(String::from(
parsed_error.message,
))
}
"InvalidClusterState" => {
return DisableSnapshotCopyError::InvalidClusterStateFault(String::from(
parsed_error.message,
))
}
"SnapshotCopyAlreadyDisabledFault" => {
return DisableSnapshotCopyError::SnapshotCopyAlreadyDisabledFault(
String::from(parsed_error.message),
)
}
"UnauthorizedOperation" => {
return DisableSnapshotCopyError::UnauthorizedOperation(String::from(
parsed_error.message,
))
}
_ => {}
}
}
}
DisableSnapshotCopyError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for DisableSnapshotCopyError {
fn from(err: XmlParseError) -> DisableSnapshotCopyError {
let XmlParseError(message) = err;
DisableSnapshotCopyError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DisableSnapshotCopyError {
fn from(err: CredentialsError) -> DisableSnapshotCopyError {
DisableSnapshotCopyError::Credentials(err)
}
}
impl From<HttpDispatchError> for DisableSnapshotCopyError {
fn from(err: HttpDispatchError) -> DisableSnapshotCopyError {
DisableSnapshotCopyError::HttpDispatch(err)
}
}
impl From<io::Error> for DisableSnapshotCopyError {
fn from(err: io::Error) -> DisableSnapshotCopyError {
DisableSnapshotCopyError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DisableSnapshotCopyError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DisableSnapshotCopyError {
fn description(&self) -> &str {
match *self {
DisableSnapshotCopyError::ClusterNotFoundFault(ref cause) => cause,
DisableSnapshotCopyError::InvalidClusterStateFault(ref cause) => cause,
DisableSnapshotCopyError::SnapshotCopyAlreadyDisabledFault(ref cause) => cause,
DisableSnapshotCopyError::UnauthorizedOperation(ref cause) => cause,
DisableSnapshotCopyError::Validation(ref cause) => cause,
DisableSnapshotCopyError::Credentials(ref err) => err.description(),
DisableSnapshotCopyError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DisableSnapshotCopyError::ParseError(ref cause) => cause,
DisableSnapshotCopyError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum EnableLoggingError {
BucketNotFoundFault(String),
ClusterNotFoundFault(String),
InsufficientS3BucketPolicyFault(String),
InvalidS3BucketNameFault(String),
InvalidS3KeyPrefixFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl EnableLoggingError {
pub fn from_response(res: BufferedHttpResponse) -> EnableLoggingError {
{
let reader = EventReader::new(res.body.as_slice());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"BucketNotFoundFault" => {
return EnableLoggingError::BucketNotFoundFault(String::from(
parsed_error.message,
))
}
"ClusterNotFound" => {
return EnableLoggingError::ClusterNotFoundFault(String::from(
parsed_error.message,
))
}
"InsufficientS3BucketPolicyFault" => {
return EnableLoggingError::InsufficientS3BucketPolicyFault(String::from(
parsed_error.message,
))
}
"InvalidS3BucketNameFault" => {
return EnableLoggingError::InvalidS3BucketNameFault(String::from(
parsed_error.message,
))
}
"InvalidS3KeyPrefixFault" => {
return EnableLoggingError::InvalidS3KeyPrefixFault(String::from(
parsed_error.message,
))
}
_ => {}
}
}
}
EnableLoggingError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for EnableLoggingError {
fn from(err: XmlParseError) -> EnableLoggingError {
let XmlParseError(message) = err;
EnableLoggingError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for EnableLoggingError {
fn from(err: CredentialsError) -> EnableLoggingError {
EnableLoggingError::Credentials(err)
}
}
impl From<HttpDispatchError> for EnableLoggingError {
fn from(err: HttpDispatchError) -> EnableLoggingError {
EnableLoggingError::HttpDispatch(err)
}
}
impl From<io::Error> for EnableLoggingError {
fn from(err: io::Error) -> EnableLoggingError {
EnableLoggingError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for EnableLoggingError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for EnableLoggingError {
fn description(&self) -> &str {
match *self {
EnableLoggingError::BucketNotFoundFault(ref cause) => cause,
EnableLoggingError::ClusterNotFoundFault(ref cause) => cause,
EnableLoggingError::InsufficientS3BucketPolicyFault(ref cause) => cause,
EnableLoggingError::InvalidS3BucketNameFault(ref cause) => cause,
EnableLoggingError::InvalidS3KeyPrefixFault(ref cause) => cause,
EnableLoggingError::Validation(ref cause) => cause,
EnableLoggingError::Credentials(ref err) => err.description(),
EnableLoggingError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
EnableLoggingError::ParseError(ref cause) => cause,
EnableLoggingError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum EnableSnapshotCopyError {
ClusterNotFoundFault(String),
CopyToRegionDisabledFault(String),
DependentServiceRequestThrottlingFault(String),
IncompatibleOrderableOptions(String),
InvalidClusterStateFault(String),
LimitExceededFault(String),
SnapshotCopyAlreadyEnabledFault(String),
SnapshotCopyGrantNotFoundFault(String),
UnauthorizedOperation(String),
UnknownSnapshotCopyRegionFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl EnableSnapshotCopyError {
pub fn from_response(res: BufferedHttpResponse) -> EnableSnapshotCopyError {
{
let reader = EventReader::new(res.body.as_slice());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"ClusterNotFound" => {
return EnableSnapshotCopyError::ClusterNotFoundFault(String::from(
parsed_error.message,
))
}
"CopyToRegionDisabledFault" => {
return EnableSnapshotCopyError::CopyToRegionDisabledFault(String::from(
parsed_error.message,
))
}
"DependentServiceRequestThrottlingFault" => {
return EnableSnapshotCopyError::DependentServiceRequestThrottlingFault(
String::from(parsed_error.message),
)
}
"IncompatibleOrderableOptions" => {
return EnableSnapshotCopyError::IncompatibleOrderableOptions(String::from(
parsed_error.message,
))
}
"InvalidClusterState" => {
return EnableSnapshotCopyError::InvalidClusterStateFault(String::from(
parsed_error.message,
))
}
"LimitExceededFault" => {
return EnableSnapshotCopyError::LimitExceededFault(String::from(
parsed_error.message,
))
}
"SnapshotCopyAlreadyEnabledFault" => {
return EnableSnapshotCopyError::SnapshotCopyAlreadyEnabledFault(
String::from(parsed_error.message),
)
}
"SnapshotCopyGrantNotFoundFault" => {
return EnableSnapshotCopyError::SnapshotCopyGrantNotFoundFault(
String::from(parsed_error.message),
)
}
"UnauthorizedOperation" => {
return EnableSnapshotCopyError::UnauthorizedOperation(String::from(
parsed_error.message,
))
}
"UnknownSnapshotCopyRegionFault" => {
return EnableSnapshotCopyError::UnknownSnapshotCopyRegionFault(
String::from(parsed_error.message),
)
}
_ => {}
}
}
}
EnableSnapshotCopyError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for EnableSnapshotCopyError {
fn from(err: XmlParseError) -> EnableSnapshotCopyError {
let XmlParseError(message) = err;
EnableSnapshotCopyError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for EnableSnapshotCopyError {
fn from(err: CredentialsError) -> EnableSnapshotCopyError {
EnableSnapshotCopyError::Credentials(err)
}
}
impl From<HttpDispatchError> for EnableSnapshotCopyError {
fn from(err: HttpDispatchError) -> EnableSnapshotCopyError {
EnableSnapshotCopyError::HttpDispatch(err)
}
}
impl From<io::Error> for EnableSnapshotCopyError {
fn from(err: io::Error) -> EnableSnapshotCopyError {
EnableSnapshotCopyError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for EnableSnapshotCopyError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for EnableSnapshotCopyError {
fn description(&self) -> &str {
match *self {
EnableSnapshotCopyError::ClusterNotFoundFault(ref cause) => cause,
EnableSnapshotCopyError::CopyToRegionDisabledFault(ref cause) => cause,
EnableSnapshotCopyError::DependentServiceRequestThrottlingFault(ref cause) => cause,
EnableSnapshotCopyError::IncompatibleOrderableOptions(ref cause) => cause,
EnableSnapshotCopyError::InvalidClusterStateFault(ref cause) => cause,
EnableSnapshotCopyError::LimitExceededFault(ref cause) => cause,
EnableSnapshotCopyError::SnapshotCopyAlreadyEnabledFault(ref cause) => cause,
EnableSnapshotCopyError::SnapshotCopyGrantNotFoundFault(ref cause) => cause,
EnableSnapshotCopyError::UnauthorizedOperation(ref cause) => cause,
EnableSnapshotCopyError::UnknownSnapshotCopyRegionFault(ref cause) => cause,
EnableSnapshotCopyError::Validation(ref cause) => cause,
EnableSnapshotCopyError::Credentials(ref err) => err.description(),
EnableSnapshotCopyError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
EnableSnapshotCopyError::ParseError(ref cause) => cause,
EnableSnapshotCopyError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum GetClusterCredentialsError {
ClusterNotFoundFault(String),
UnsupportedOperationFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl GetClusterCredentialsError {
pub fn from_response(res: BufferedHttpResponse) -> GetClusterCredentialsError {
{
let reader = EventReader::new(res.body.as_slice());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"ClusterNotFound" => {
return GetClusterCredentialsError::ClusterNotFoundFault(String::from(
parsed_error.message,
))
}
"UnsupportedOperation" => {
return GetClusterCredentialsError::UnsupportedOperationFault(String::from(
parsed_error.message,
))
}
_ => {}
}
}
}
GetClusterCredentialsError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for GetClusterCredentialsError {
fn from(err: XmlParseError) -> GetClusterCredentialsError {
let XmlParseError(message) = err;
GetClusterCredentialsError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for GetClusterCredentialsError {
fn from(err: CredentialsError) -> GetClusterCredentialsError {
GetClusterCredentialsError::Credentials(err)
}
}
impl From<HttpDispatchError> for GetClusterCredentialsError {
fn from(err: HttpDispatchError) -> GetClusterCredentialsError {
GetClusterCredentialsError::HttpDispatch(err)
}
}
impl From<io::Error> for GetClusterCredentialsError {
fn from(err: io::Error) -> GetClusterCredentialsError {
GetClusterCredentialsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for GetClusterCredentialsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetClusterCredentialsError {
fn description(&self) -> &str {
match *self {
GetClusterCredentialsError::ClusterNotFoundFault(ref cause) => cause,
GetClusterCredentialsError::UnsupportedOperationFault(ref cause) => cause,
GetClusterCredentialsError::Validation(ref cause) => cause,
GetClusterCredentialsError::Credentials(ref err) => err.description(),
GetClusterCredentialsError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
GetClusterCredentialsError::ParseError(ref cause) => cause,
GetClusterCredentialsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum GetReservedNodeExchangeOfferingsError {
DependentServiceUnavailableFault(String),
InvalidReservedNodeStateFault(String),
ReservedNodeAlreadyMigratedFault(String),
ReservedNodeNotFoundFault(String),
ReservedNodeOfferingNotFoundFault(String),
UnsupportedOperationFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl GetReservedNodeExchangeOfferingsError {
pub fn from_response(res: BufferedHttpResponse) -> GetReservedNodeExchangeOfferingsError {
{
let reader = EventReader::new(res.body.as_slice());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"DependentServiceUnavailableFault" => return GetReservedNodeExchangeOfferingsError::DependentServiceUnavailableFault(String::from(parsed_error.message)),"InvalidReservedNodeState" => return GetReservedNodeExchangeOfferingsError::InvalidReservedNodeStateFault(String::from(parsed_error.message)),"ReservedNodeAlreadyMigrated" => return GetReservedNodeExchangeOfferingsError::ReservedNodeAlreadyMigratedFault(String::from(parsed_error.message)),"ReservedNodeNotFound" => return GetReservedNodeExchangeOfferingsError::ReservedNodeNotFoundFault(String::from(parsed_error.message)),"ReservedNodeOfferingNotFound" => return GetReservedNodeExchangeOfferingsError::ReservedNodeOfferingNotFoundFault(String::from(parsed_error.message)),"UnsupportedOperation" => return GetReservedNodeExchangeOfferingsError::UnsupportedOperationFault(String::from(parsed_error.message)),_ => {}
}
}
}
GetReservedNodeExchangeOfferingsError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for GetReservedNodeExchangeOfferingsError {
fn from(err: XmlParseError) -> GetReservedNodeExchangeOfferingsError {
let XmlParseError(message) = err;
GetReservedNodeExchangeOfferingsError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for GetReservedNodeExchangeOfferingsError {
fn from(err: CredentialsError) -> GetReservedNodeExchangeOfferingsError {
GetReservedNodeExchangeOfferingsError::Credentials(err)
}
}
impl From<HttpDispatchError> for GetReservedNodeExchangeOfferingsError {
fn from(err: HttpDispatchError) -> GetReservedNodeExchangeOfferingsError {
GetReservedNodeExchangeOfferingsError::HttpDispatch(err)
}
}
impl From<io::Error> for GetReservedNodeExchangeOfferingsError {
fn from(err: io::Error) -> GetReservedNodeExchangeOfferingsError {
GetReservedNodeExchangeOfferingsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for GetReservedNodeExchangeOfferingsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetReservedNodeExchangeOfferingsError {
fn description(&self) -> &str {
match *self {
GetReservedNodeExchangeOfferingsError::DependentServiceUnavailableFault(ref cause) => {
cause
}
GetReservedNodeExchangeOfferingsError::InvalidReservedNodeStateFault(ref cause) => {
cause
}
GetReservedNodeExchangeOfferingsError::ReservedNodeAlreadyMigratedFault(ref cause) => {
cause
}
GetReservedNodeExchangeOfferingsError::ReservedNodeNotFoundFault(ref cause) => cause,
GetReservedNodeExchangeOfferingsError::ReservedNodeOfferingNotFoundFault(ref cause) => {
cause
}
GetReservedNodeExchangeOfferingsError::UnsupportedOperationFault(ref cause) => cause,
GetReservedNodeExchangeOfferingsError::Validation(ref cause) => cause,
GetReservedNodeExchangeOfferingsError::Credentials(ref err) => err.description(),
GetReservedNodeExchangeOfferingsError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
GetReservedNodeExchangeOfferingsError::ParseError(ref cause) => cause,
GetReservedNodeExchangeOfferingsError::Unknown(_) => "unknown error",
}
}
}
#[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),
LimitExceededFault(String),
NumberOfNodesPerClusterLimitExceededFault(String),
NumberOfNodesQuotaExceededFault(String),
TableLimitExceededFault(String),
UnauthorizedOperation(String),
UnsupportedOptionFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ModifyClusterError {
pub fn from_response(res: BufferedHttpResponse) -> ModifyClusterError {
{
let reader = EventReader::new(res.body.as_slice());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"ClusterAlreadyExists" => {
return ModifyClusterError::ClusterAlreadyExistsFault(String::from(
parsed_error.message,
))
}
"ClusterNotFound" => {
return ModifyClusterError::ClusterNotFoundFault(String::from(
parsed_error.message,
))
}
"ClusterParameterGroupNotFound" => {
return ModifyClusterError::ClusterParameterGroupNotFoundFault(String::from(
parsed_error.message,
))
}
"ClusterSecurityGroupNotFound" => {
return ModifyClusterError::ClusterSecurityGroupNotFoundFault(String::from(
parsed_error.message,
))
}
"DependentServiceRequestThrottlingFault" => {
return ModifyClusterError::DependentServiceRequestThrottlingFault(
String::from(parsed_error.message),
)
}
"HsmClientCertificateNotFoundFault" => {
return ModifyClusterError::HsmClientCertificateNotFoundFault(String::from(
parsed_error.message,
))
}
"HsmConfigurationNotFoundFault" => {
return ModifyClusterError::HsmConfigurationNotFoundFault(String::from(
parsed_error.message,
))
}
"InsufficientClusterCapacity" => {
return ModifyClusterError::InsufficientClusterCapacityFault(String::from(
parsed_error.message,
))
}
"InvalidClusterSecurityGroupState" => {
return ModifyClusterError::InvalidClusterSecurityGroupStateFault(
String::from(parsed_error.message),
)
}
"InvalidClusterState" => {
return ModifyClusterError::InvalidClusterStateFault(String::from(
parsed_error.message,
))
}
"InvalidClusterTrack" => {
return ModifyClusterError::InvalidClusterTrackFault(String::from(
parsed_error.message,
))
}
"InvalidElasticIpFault" => {
return ModifyClusterError::InvalidElasticIpFault(String::from(
parsed_error.message,
))
}
"LimitExceededFault" => {
return ModifyClusterError::LimitExceededFault(String::from(
parsed_error.message,
))
}
"NumberOfNodesPerClusterLimitExceeded" => {
return ModifyClusterError::NumberOfNodesPerClusterLimitExceededFault(
String::from(parsed_error.message),
)
}
"NumberOfNodesQuotaExceeded" => {
return ModifyClusterError::NumberOfNodesQuotaExceededFault(String::from(
parsed_error.message,
))
}
"TableLimitExceeded" => {
return ModifyClusterError::TableLimitExceededFault(String::from(
parsed_error.message,
))
}
"UnauthorizedOperation" => {
return ModifyClusterError::UnauthorizedOperation(String::from(
parsed_error.message,
))
}
"UnsupportedOptionFault" => {
return ModifyClusterError::UnsupportedOptionFault(String::from(
parsed_error.message,
))
}
_ => {}
}
}
}
ModifyClusterError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for ModifyClusterError {
fn from(err: XmlParseError) -> ModifyClusterError {
let XmlParseError(message) = err;
ModifyClusterError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for ModifyClusterError {
fn from(err: CredentialsError) -> ModifyClusterError {
ModifyClusterError::Credentials(err)
}
}
impl From<HttpDispatchError> for ModifyClusterError {
fn from(err: HttpDispatchError) -> ModifyClusterError {
ModifyClusterError::HttpDispatch(err)
}
}
impl From<io::Error> for ModifyClusterError {
fn from(err: io::Error) -> ModifyClusterError {
ModifyClusterError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ModifyClusterError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ModifyClusterError {
fn description(&self) -> &str {
match *self {
ModifyClusterError::ClusterAlreadyExistsFault(ref cause) => cause,
ModifyClusterError::ClusterNotFoundFault(ref cause) => cause,
ModifyClusterError::ClusterParameterGroupNotFoundFault(ref cause) => cause,
ModifyClusterError::ClusterSecurityGroupNotFoundFault(ref cause) => cause,
ModifyClusterError::DependentServiceRequestThrottlingFault(ref cause) => cause,
ModifyClusterError::HsmClientCertificateNotFoundFault(ref cause) => cause,
ModifyClusterError::HsmConfigurationNotFoundFault(ref cause) => cause,
ModifyClusterError::InsufficientClusterCapacityFault(ref cause) => cause,
ModifyClusterError::InvalidClusterSecurityGroupStateFault(ref cause) => cause,
ModifyClusterError::InvalidClusterStateFault(ref cause) => cause,
ModifyClusterError::InvalidClusterTrackFault(ref cause) => cause,
ModifyClusterError::InvalidElasticIpFault(ref cause) => cause,
ModifyClusterError::LimitExceededFault(ref cause) => cause,
ModifyClusterError::NumberOfNodesPerClusterLimitExceededFault(ref cause) => cause,
ModifyClusterError::NumberOfNodesQuotaExceededFault(ref cause) => cause,
ModifyClusterError::TableLimitExceededFault(ref cause) => cause,
ModifyClusterError::UnauthorizedOperation(ref cause) => cause,
ModifyClusterError::UnsupportedOptionFault(ref cause) => cause,
ModifyClusterError::Validation(ref cause) => cause,
ModifyClusterError::Credentials(ref err) => err.description(),
ModifyClusterError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
ModifyClusterError::ParseError(ref cause) => cause,
ModifyClusterError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ModifyClusterDbRevisionError {
ClusterNotFoundFault(String),
ClusterOnLatestRevisionFault(String),
InvalidClusterStateFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ModifyClusterDbRevisionError {
pub fn from_response(res: BufferedHttpResponse) -> ModifyClusterDbRevisionError {
{
let reader = EventReader::new(res.body.as_slice());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"ClusterNotFound" => {
return ModifyClusterDbRevisionError::ClusterNotFoundFault(String::from(
parsed_error.message,
))
}
"ClusterOnLatestRevision" => {
return ModifyClusterDbRevisionError::ClusterOnLatestRevisionFault(
String::from(parsed_error.message),
)
}
"InvalidClusterState" => {
return ModifyClusterDbRevisionError::InvalidClusterStateFault(String::from(
parsed_error.message,
))
}
_ => {}
}
}
}
ModifyClusterDbRevisionError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for ModifyClusterDbRevisionError {
fn from(err: XmlParseError) -> ModifyClusterDbRevisionError {
let XmlParseError(message) = err;
ModifyClusterDbRevisionError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for ModifyClusterDbRevisionError {
fn from(err: CredentialsError) -> ModifyClusterDbRevisionError {
ModifyClusterDbRevisionError::Credentials(err)
}
}
impl From<HttpDispatchError> for ModifyClusterDbRevisionError {
fn from(err: HttpDispatchError) -> ModifyClusterDbRevisionError {
ModifyClusterDbRevisionError::HttpDispatch(err)
}
}
impl From<io::Error> for ModifyClusterDbRevisionError {
fn from(err: io::Error) -> ModifyClusterDbRevisionError {
ModifyClusterDbRevisionError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ModifyClusterDbRevisionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ModifyClusterDbRevisionError {
fn description(&self) -> &str {
match *self {
ModifyClusterDbRevisionError::ClusterNotFoundFault(ref cause) => cause,
ModifyClusterDbRevisionError::ClusterOnLatestRevisionFault(ref cause) => cause,
ModifyClusterDbRevisionError::InvalidClusterStateFault(ref cause) => cause,
ModifyClusterDbRevisionError::Validation(ref cause) => cause,
ModifyClusterDbRevisionError::Credentials(ref err) => err.description(),
ModifyClusterDbRevisionError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
ModifyClusterDbRevisionError::ParseError(ref cause) => cause,
ModifyClusterDbRevisionError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ModifyClusterIamRolesError {
ClusterNotFoundFault(String),
InvalidClusterStateFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ModifyClusterIamRolesError {
pub fn from_response(res: BufferedHttpResponse) -> ModifyClusterIamRolesError {
{
let reader = EventReader::new(res.body.as_slice());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"ClusterNotFound" => {
return ModifyClusterIamRolesError::ClusterNotFoundFault(String::from(
parsed_error.message,
))
}
"InvalidClusterState" => {
return ModifyClusterIamRolesError::InvalidClusterStateFault(String::from(
parsed_error.message,
))
}
_ => {}
}
}
}
ModifyClusterIamRolesError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for ModifyClusterIamRolesError {
fn from(err: XmlParseError) -> ModifyClusterIamRolesError {
let XmlParseError(message) = err;
ModifyClusterIamRolesError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for ModifyClusterIamRolesError {
fn from(err: CredentialsError) -> ModifyClusterIamRolesError {
ModifyClusterIamRolesError::Credentials(err)
}
}
impl From<HttpDispatchError> for ModifyClusterIamRolesError {
fn from(err: HttpDispatchError) -> ModifyClusterIamRolesError {
ModifyClusterIamRolesError::HttpDispatch(err)
}
}
impl From<io::Error> for ModifyClusterIamRolesError {
fn from(err: io::Error) -> ModifyClusterIamRolesError {
ModifyClusterIamRolesError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ModifyClusterIamRolesError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ModifyClusterIamRolesError {
fn description(&self) -> &str {
match *self {
ModifyClusterIamRolesError::ClusterNotFoundFault(ref cause) => cause,
ModifyClusterIamRolesError::InvalidClusterStateFault(ref cause) => cause,
ModifyClusterIamRolesError::Validation(ref cause) => cause,
ModifyClusterIamRolesError::Credentials(ref err) => err.description(),
ModifyClusterIamRolesError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
ModifyClusterIamRolesError::ParseError(ref cause) => cause,
ModifyClusterIamRolesError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ModifyClusterParameterGroupError {
ClusterParameterGroupNotFoundFault(String),
InvalidClusterParameterGroupStateFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ModifyClusterParameterGroupError {
pub fn from_response(res: BufferedHttpResponse) -> ModifyClusterParameterGroupError {
{
let reader = EventReader::new(res.body.as_slice());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"ClusterParameterGroupNotFound" => return ModifyClusterParameterGroupError::ClusterParameterGroupNotFoundFault(String::from(parsed_error.message)),"InvalidClusterParameterGroupState" => return ModifyClusterParameterGroupError::InvalidClusterParameterGroupStateFault(String::from(parsed_error.message)),_ => {}
}
}
}
ModifyClusterParameterGroupError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for ModifyClusterParameterGroupError {
fn from(err: XmlParseError) -> ModifyClusterParameterGroupError {
let XmlParseError(message) = err;
ModifyClusterParameterGroupError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for ModifyClusterParameterGroupError {
fn from(err: CredentialsError) -> ModifyClusterParameterGroupError {
ModifyClusterParameterGroupError::Credentials(err)
}
}
impl From<HttpDispatchError> for ModifyClusterParameterGroupError {
fn from(err: HttpDispatchError) -> ModifyClusterParameterGroupError {
ModifyClusterParameterGroupError::HttpDispatch(err)
}
}
impl From<io::Error> for ModifyClusterParameterGroupError {
fn from(err: io::Error) -> ModifyClusterParameterGroupError {
ModifyClusterParameterGroupError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ModifyClusterParameterGroupError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ModifyClusterParameterGroupError {
fn description(&self) -> &str {
match *self {
ModifyClusterParameterGroupError::ClusterParameterGroupNotFoundFault(ref cause) => {
cause
}
ModifyClusterParameterGroupError::InvalidClusterParameterGroupStateFault(ref cause) => {
cause
}
ModifyClusterParameterGroupError::Validation(ref cause) => cause,
ModifyClusterParameterGroupError::Credentials(ref err) => err.description(),
ModifyClusterParameterGroupError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
ModifyClusterParameterGroupError::ParseError(ref cause) => cause,
ModifyClusterParameterGroupError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ModifyClusterSubnetGroupError {
ClusterSubnetGroupNotFoundFault(String),
ClusterSubnetQuotaExceededFault(String),
DependentServiceRequestThrottlingFault(String),
InvalidSubnet(String),
SubnetAlreadyInUse(String),
UnauthorizedOperation(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ModifyClusterSubnetGroupError {
pub fn from_response(res: BufferedHttpResponse) -> ModifyClusterSubnetGroupError {
{
let reader = EventReader::new(res.body.as_slice());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"ClusterSubnetGroupNotFoundFault" => {
return ModifyClusterSubnetGroupError::ClusterSubnetGroupNotFoundFault(
String::from(parsed_error.message),
)
}
"ClusterSubnetQuotaExceededFault" => {
return ModifyClusterSubnetGroupError::ClusterSubnetQuotaExceededFault(
String::from(parsed_error.message),
)
}
"DependentServiceRequestThrottlingFault" => {
return ModifyClusterSubnetGroupError::DependentServiceRequestThrottlingFault(
String::from(parsed_error.message),
)
}
"InvalidSubnet" => {
return ModifyClusterSubnetGroupError::InvalidSubnet(String::from(
parsed_error.message,
))
}
"SubnetAlreadyInUse" => {
return ModifyClusterSubnetGroupError::SubnetAlreadyInUse(String::from(
parsed_error.message,
))
}
"UnauthorizedOperation" => {
return ModifyClusterSubnetGroupError::UnauthorizedOperation(String::from(
parsed_error.message,
))
}
_ => {}
}
}
}
ModifyClusterSubnetGroupError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for ModifyClusterSubnetGroupError {
fn from(err: XmlParseError) -> ModifyClusterSubnetGroupError {
let XmlParseError(message) = err;
ModifyClusterSubnetGroupError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for ModifyClusterSubnetGroupError {
fn from(err: CredentialsError) -> ModifyClusterSubnetGroupError {
ModifyClusterSubnetGroupError::Credentials(err)
}
}
impl From<HttpDispatchError> for ModifyClusterSubnetGroupError {
fn from(err: HttpDispatchError) -> ModifyClusterSubnetGroupError {
ModifyClusterSubnetGroupError::HttpDispatch(err)
}
}
impl From<io::Error> for ModifyClusterSubnetGroupError {
fn from(err: io::Error) -> ModifyClusterSubnetGroupError {
ModifyClusterSubnetGroupError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ModifyClusterSubnetGroupError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ModifyClusterSubnetGroupError {
fn description(&self) -> &str {
match *self {
ModifyClusterSubnetGroupError::ClusterSubnetGroupNotFoundFault(ref cause) => cause,
ModifyClusterSubnetGroupError::ClusterSubnetQuotaExceededFault(ref cause) => cause,
ModifyClusterSubnetGroupError::DependentServiceRequestThrottlingFault(ref cause) => {
cause
}
ModifyClusterSubnetGroupError::InvalidSubnet(ref cause) => cause,
ModifyClusterSubnetGroupError::SubnetAlreadyInUse(ref cause) => cause,
ModifyClusterSubnetGroupError::UnauthorizedOperation(ref cause) => cause,
ModifyClusterSubnetGroupError::Validation(ref cause) => cause,
ModifyClusterSubnetGroupError::Credentials(ref err) => err.description(),
ModifyClusterSubnetGroupError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
ModifyClusterSubnetGroupError::ParseError(ref cause) => cause,
ModifyClusterSubnetGroupError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ModifyEventSubscriptionError {
InvalidSubscriptionStateFault(String),
SNSInvalidTopicFault(String),
SNSNoAuthorizationFault(String),
SNSTopicArnNotFoundFault(String),
SourceNotFoundFault(String),
SubscriptionCategoryNotFoundFault(String),
SubscriptionEventIdNotFoundFault(String),
SubscriptionNotFoundFault(String),
SubscriptionSeverityNotFoundFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ModifyEventSubscriptionError {
pub fn from_response(res: BufferedHttpResponse) -> ModifyEventSubscriptionError {
{
let reader = EventReader::new(res.body.as_slice());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"InvalidSubscriptionStateFault" => {
return ModifyEventSubscriptionError::InvalidSubscriptionStateFault(
String::from(parsed_error.message),
)
}
"SNSInvalidTopic" => {
return ModifyEventSubscriptionError::SNSInvalidTopicFault(String::from(
parsed_error.message,
))
}
"SNSNoAuthorization" => {
return ModifyEventSubscriptionError::SNSNoAuthorizationFault(String::from(
parsed_error.message,
))
}
"SNSTopicArnNotFound" => {
return ModifyEventSubscriptionError::SNSTopicArnNotFoundFault(String::from(
parsed_error.message,
))
}
"SourceNotFound" => {
return ModifyEventSubscriptionError::SourceNotFoundFault(String::from(
parsed_error.message,
))
}
"SubscriptionCategoryNotFound" => {
return ModifyEventSubscriptionError::SubscriptionCategoryNotFoundFault(
String::from(parsed_error.message),
)
}
"SubscriptionEventIdNotFound" => {
return ModifyEventSubscriptionError::SubscriptionEventIdNotFoundFault(
String::from(parsed_error.message),
)
}
"SubscriptionNotFound" => {
return ModifyEventSubscriptionError::SubscriptionNotFoundFault(
String::from(parsed_error.message),
)
}
"SubscriptionSeverityNotFound" => {
return ModifyEventSubscriptionError::SubscriptionSeverityNotFoundFault(
String::from(parsed_error.message),
)
}
_ => {}
}
}
}
ModifyEventSubscriptionError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for ModifyEventSubscriptionError {
fn from(err: XmlParseError) -> ModifyEventSubscriptionError {
let XmlParseError(message) = err;
ModifyEventSubscriptionError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for ModifyEventSubscriptionError {
fn from(err: CredentialsError) -> ModifyEventSubscriptionError {
ModifyEventSubscriptionError::Credentials(err)
}
}
impl From<HttpDispatchError> for ModifyEventSubscriptionError {
fn from(err: HttpDispatchError) -> ModifyEventSubscriptionError {
ModifyEventSubscriptionError::HttpDispatch(err)
}
}
impl From<io::Error> for ModifyEventSubscriptionError {
fn from(err: io::Error) -> ModifyEventSubscriptionError {
ModifyEventSubscriptionError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ModifyEventSubscriptionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ModifyEventSubscriptionError {
fn description(&self) -> &str {
match *self {
ModifyEventSubscriptionError::InvalidSubscriptionStateFault(ref cause) => cause,
ModifyEventSubscriptionError::SNSInvalidTopicFault(ref cause) => cause,
ModifyEventSubscriptionError::SNSNoAuthorizationFault(ref cause) => cause,
ModifyEventSubscriptionError::SNSTopicArnNotFoundFault(ref cause) => cause,
ModifyEventSubscriptionError::SourceNotFoundFault(ref cause) => cause,
ModifyEventSubscriptionError::SubscriptionCategoryNotFoundFault(ref cause) => cause,
ModifyEventSubscriptionError::SubscriptionEventIdNotFoundFault(ref cause) => cause,
ModifyEventSubscriptionError::SubscriptionNotFoundFault(ref cause) => cause,
ModifyEventSubscriptionError::SubscriptionSeverityNotFoundFault(ref cause) => cause,
ModifyEventSubscriptionError::Validation(ref cause) => cause,
ModifyEventSubscriptionError::Credentials(ref err) => err.description(),
ModifyEventSubscriptionError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
ModifyEventSubscriptionError::ParseError(ref cause) => cause,
ModifyEventSubscriptionError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ModifySnapshotCopyRetentionPeriodError {
ClusterNotFoundFault(String),
InvalidClusterStateFault(String),
SnapshotCopyDisabledFault(String),
UnauthorizedOperation(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ModifySnapshotCopyRetentionPeriodError {
pub fn from_response(res: BufferedHttpResponse) -> ModifySnapshotCopyRetentionPeriodError {
{
let reader = EventReader::new(res.body.as_slice());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"ClusterNotFound" => {
return ModifySnapshotCopyRetentionPeriodError::ClusterNotFoundFault(
String::from(parsed_error.message),
)
}
"InvalidClusterState" => {
return ModifySnapshotCopyRetentionPeriodError::InvalidClusterStateFault(
String::from(parsed_error.message),
)
}
"SnapshotCopyDisabledFault" => {
return ModifySnapshotCopyRetentionPeriodError::SnapshotCopyDisabledFault(
String::from(parsed_error.message),
)
}
"UnauthorizedOperation" => {
return ModifySnapshotCopyRetentionPeriodError::UnauthorizedOperation(
String::from(parsed_error.message),
)
}
_ => {}
}
}
}
ModifySnapshotCopyRetentionPeriodError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for ModifySnapshotCopyRetentionPeriodError {
fn from(err: XmlParseError) -> ModifySnapshotCopyRetentionPeriodError {
let XmlParseError(message) = err;
ModifySnapshotCopyRetentionPeriodError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for ModifySnapshotCopyRetentionPeriodError {
fn from(err: CredentialsError) -> ModifySnapshotCopyRetentionPeriodError {
ModifySnapshotCopyRetentionPeriodError::Credentials(err)
}
}
impl From<HttpDispatchError> for ModifySnapshotCopyRetentionPeriodError {
fn from(err: HttpDispatchError) -> ModifySnapshotCopyRetentionPeriodError {
ModifySnapshotCopyRetentionPeriodError::HttpDispatch(err)
}
}
impl From<io::Error> for ModifySnapshotCopyRetentionPeriodError {
fn from(err: io::Error) -> ModifySnapshotCopyRetentionPeriodError {
ModifySnapshotCopyRetentionPeriodError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ModifySnapshotCopyRetentionPeriodError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ModifySnapshotCopyRetentionPeriodError {
fn description(&self) -> &str {
match *self {
ModifySnapshotCopyRetentionPeriodError::ClusterNotFoundFault(ref cause) => cause,
ModifySnapshotCopyRetentionPeriodError::InvalidClusterStateFault(ref cause) => cause,
ModifySnapshotCopyRetentionPeriodError::SnapshotCopyDisabledFault(ref cause) => cause,
ModifySnapshotCopyRetentionPeriodError::UnauthorizedOperation(ref cause) => cause,
ModifySnapshotCopyRetentionPeriodError::Validation(ref cause) => cause,
ModifySnapshotCopyRetentionPeriodError::Credentials(ref err) => err.description(),
ModifySnapshotCopyRetentionPeriodError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
ModifySnapshotCopyRetentionPeriodError::ParseError(ref cause) => cause,
ModifySnapshotCopyRetentionPeriodError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum PurchaseReservedNodeOfferingError {
ReservedNodeAlreadyExistsFault(String),
ReservedNodeOfferingNotFoundFault(String),
ReservedNodeQuotaExceededFault(String),
UnsupportedOperationFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl PurchaseReservedNodeOfferingError {
pub fn from_response(res: BufferedHttpResponse) -> PurchaseReservedNodeOfferingError {
{
let reader = EventReader::new(res.body.as_slice());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"ReservedNodeAlreadyExists" => {
return PurchaseReservedNodeOfferingError::ReservedNodeAlreadyExistsFault(
String::from(parsed_error.message),
)
}
"ReservedNodeOfferingNotFound" => {
return PurchaseReservedNodeOfferingError::ReservedNodeOfferingNotFoundFault(
String::from(parsed_error.message),
)
}
"ReservedNodeQuotaExceeded" => {
return PurchaseReservedNodeOfferingError::ReservedNodeQuotaExceededFault(
String::from(parsed_error.message),
)
}
"UnsupportedOperation" => {
return PurchaseReservedNodeOfferingError::UnsupportedOperationFault(
String::from(parsed_error.message),
)
}
_ => {}
}
}
}
PurchaseReservedNodeOfferingError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for PurchaseReservedNodeOfferingError {
fn from(err: XmlParseError) -> PurchaseReservedNodeOfferingError {
let XmlParseError(message) = err;
PurchaseReservedNodeOfferingError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for PurchaseReservedNodeOfferingError {
fn from(err: CredentialsError) -> PurchaseReservedNodeOfferingError {
PurchaseReservedNodeOfferingError::Credentials(err)
}
}
impl From<HttpDispatchError> for PurchaseReservedNodeOfferingError {
fn from(err: HttpDispatchError) -> PurchaseReservedNodeOfferingError {
PurchaseReservedNodeOfferingError::HttpDispatch(err)
}
}
impl From<io::Error> for PurchaseReservedNodeOfferingError {
fn from(err: io::Error) -> PurchaseReservedNodeOfferingError {
PurchaseReservedNodeOfferingError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for PurchaseReservedNodeOfferingError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for PurchaseReservedNodeOfferingError {
fn description(&self) -> &str {
match *self {
PurchaseReservedNodeOfferingError::ReservedNodeAlreadyExistsFault(ref cause) => cause,
PurchaseReservedNodeOfferingError::ReservedNodeOfferingNotFoundFault(ref cause) => {
cause
}
PurchaseReservedNodeOfferingError::ReservedNodeQuotaExceededFault(ref cause) => cause,
PurchaseReservedNodeOfferingError::UnsupportedOperationFault(ref cause) => cause,
PurchaseReservedNodeOfferingError::Validation(ref cause) => cause,
PurchaseReservedNodeOfferingError::Credentials(ref err) => err.description(),
PurchaseReservedNodeOfferingError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
PurchaseReservedNodeOfferingError::ParseError(ref cause) => cause,
PurchaseReservedNodeOfferingError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum RebootClusterError {
ClusterNotFoundFault(String),
InvalidClusterStateFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl RebootClusterError {
pub fn from_response(res: BufferedHttpResponse) -> RebootClusterError {
{
let reader = EventReader::new(res.body.as_slice());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"ClusterNotFound" => {
return RebootClusterError::ClusterNotFoundFault(String::from(
parsed_error.message,
))
}
"InvalidClusterState" => {
return RebootClusterError::InvalidClusterStateFault(String::from(
parsed_error.message,
))
}
_ => {}
}
}
}
RebootClusterError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for RebootClusterError {
fn from(err: XmlParseError) -> RebootClusterError {
let XmlParseError(message) = err;
RebootClusterError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for RebootClusterError {
fn from(err: CredentialsError) -> RebootClusterError {
RebootClusterError::Credentials(err)
}
}
impl From<HttpDispatchError> for RebootClusterError {
fn from(err: HttpDispatchError) -> RebootClusterError {
RebootClusterError::HttpDispatch(err)
}
}
impl From<io::Error> for RebootClusterError {
fn from(err: io::Error) -> RebootClusterError {
RebootClusterError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for RebootClusterError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for RebootClusterError {
fn description(&self) -> &str {
match *self {
RebootClusterError::ClusterNotFoundFault(ref cause) => cause,
RebootClusterError::InvalidClusterStateFault(ref cause) => cause,
RebootClusterError::Validation(ref cause) => cause,
RebootClusterError::Credentials(ref err) => err.description(),
RebootClusterError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
RebootClusterError::ParseError(ref cause) => cause,
RebootClusterError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ResetClusterParameterGroupError {
ClusterParameterGroupNotFoundFault(String),
InvalidClusterParameterGroupStateFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ResetClusterParameterGroupError {
pub fn from_response(res: BufferedHttpResponse) -> ResetClusterParameterGroupError {
{
let reader = EventReader::new(res.body.as_slice());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"ClusterParameterGroupNotFound" => return ResetClusterParameterGroupError::ClusterParameterGroupNotFoundFault(String::from(parsed_error.message)),"InvalidClusterParameterGroupState" => return ResetClusterParameterGroupError::InvalidClusterParameterGroupStateFault(String::from(parsed_error.message)),_ => {}
}
}
}
ResetClusterParameterGroupError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for ResetClusterParameterGroupError {
fn from(err: XmlParseError) -> ResetClusterParameterGroupError {
let XmlParseError(message) = err;
ResetClusterParameterGroupError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for ResetClusterParameterGroupError {
fn from(err: CredentialsError) -> ResetClusterParameterGroupError {
ResetClusterParameterGroupError::Credentials(err)
}
}
impl From<HttpDispatchError> for ResetClusterParameterGroupError {
fn from(err: HttpDispatchError) -> ResetClusterParameterGroupError {
ResetClusterParameterGroupError::HttpDispatch(err)
}
}
impl From<io::Error> for ResetClusterParameterGroupError {
fn from(err: io::Error) -> ResetClusterParameterGroupError {
ResetClusterParameterGroupError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ResetClusterParameterGroupError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ResetClusterParameterGroupError {
fn description(&self) -> &str {
match *self {
ResetClusterParameterGroupError::ClusterParameterGroupNotFoundFault(ref cause) => cause,
ResetClusterParameterGroupError::InvalidClusterParameterGroupStateFault(ref cause) => {
cause
}
ResetClusterParameterGroupError::Validation(ref cause) => cause,
ResetClusterParameterGroupError::Credentials(ref err) => err.description(),
ResetClusterParameterGroupError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
ResetClusterParameterGroupError::ParseError(ref cause) => cause,
ResetClusterParameterGroupError::Unknown(_) => "unknown error",
}
}
}
#[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),
InvalidVPCNetworkStateFault(String),
LimitExceededFault(String),
NumberOfNodesPerClusterLimitExceededFault(String),
NumberOfNodesQuotaExceededFault(String),
UnauthorizedOperation(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl RestoreFromClusterSnapshotError {
pub fn from_response(res: BufferedHttpResponse) -> RestoreFromClusterSnapshotError {
{
let reader = EventReader::new(res.body.as_slice());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"AccessToSnapshotDenied" => return RestoreFromClusterSnapshotError::AccessToSnapshotDeniedFault(String::from(parsed_error.message)),"ClusterAlreadyExists" => return RestoreFromClusterSnapshotError::ClusterAlreadyExistsFault(String::from(parsed_error.message)),"ClusterParameterGroupNotFound" => return RestoreFromClusterSnapshotError::ClusterParameterGroupNotFoundFault(String::from(parsed_error.message)),"ClusterQuotaExceeded" => return RestoreFromClusterSnapshotError::ClusterQuotaExceededFault(String::from(parsed_error.message)),"ClusterSecurityGroupNotFound" => return RestoreFromClusterSnapshotError::ClusterSecurityGroupNotFoundFault(String::from(parsed_error.message)),"ClusterSnapshotNotFound" => return RestoreFromClusterSnapshotError::ClusterSnapshotNotFoundFault(String::from(parsed_error.message)),"ClusterSubnetGroupNotFoundFault" => return RestoreFromClusterSnapshotError::ClusterSubnetGroupNotFoundFault(String::from(parsed_error.message)),"DependentServiceRequestThrottlingFault" => return RestoreFromClusterSnapshotError::DependentServiceRequestThrottlingFault(String::from(parsed_error.message)),"HsmClientCertificateNotFoundFault" => return RestoreFromClusterSnapshotError::HsmClientCertificateNotFoundFault(String::from(parsed_error.message)),"HsmConfigurationNotFoundFault" => return RestoreFromClusterSnapshotError::HsmConfigurationNotFoundFault(String::from(parsed_error.message)),"InsufficientClusterCapacity" => return RestoreFromClusterSnapshotError::InsufficientClusterCapacityFault(String::from(parsed_error.message)),"InvalidClusterSnapshotState" => return RestoreFromClusterSnapshotError::InvalidClusterSnapshotStateFault(String::from(parsed_error.message)),"InvalidClusterSubnetGroupStateFault" => return RestoreFromClusterSnapshotError::InvalidClusterSubnetGroupStateFault(String::from(parsed_error.message)),"InvalidClusterTrack" => return RestoreFromClusterSnapshotError::InvalidClusterTrackFault(String::from(parsed_error.message)),"InvalidElasticIpFault" => return RestoreFromClusterSnapshotError::InvalidElasticIpFault(String::from(parsed_error.message)),"InvalidRestore" => return RestoreFromClusterSnapshotError::InvalidRestoreFault(String::from(parsed_error.message)),"InvalidSubnet" => return RestoreFromClusterSnapshotError::InvalidSubnet(String::from(parsed_error.message)),"InvalidVPCNetworkStateFault" => return RestoreFromClusterSnapshotError::InvalidVPCNetworkStateFault(String::from(parsed_error.message)),"LimitExceededFault" => return RestoreFromClusterSnapshotError::LimitExceededFault(String::from(parsed_error.message)),"NumberOfNodesPerClusterLimitExceeded" => return RestoreFromClusterSnapshotError::NumberOfNodesPerClusterLimitExceededFault(String::from(parsed_error.message)),"NumberOfNodesQuotaExceeded" => return RestoreFromClusterSnapshotError::NumberOfNodesQuotaExceededFault(String::from(parsed_error.message)),"UnauthorizedOperation" => return RestoreFromClusterSnapshotError::UnauthorizedOperation(String::from(parsed_error.message)),_ => {}
}
}
}
RestoreFromClusterSnapshotError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for RestoreFromClusterSnapshotError {
fn from(err: XmlParseError) -> RestoreFromClusterSnapshotError {
let XmlParseError(message) = err;
RestoreFromClusterSnapshotError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for RestoreFromClusterSnapshotError {
fn from(err: CredentialsError) -> RestoreFromClusterSnapshotError {
RestoreFromClusterSnapshotError::Credentials(err)
}
}
impl From<HttpDispatchError> for RestoreFromClusterSnapshotError {
fn from(err: HttpDispatchError) -> RestoreFromClusterSnapshotError {
RestoreFromClusterSnapshotError::HttpDispatch(err)
}
}
impl From<io::Error> for RestoreFromClusterSnapshotError {
fn from(err: io::Error) -> RestoreFromClusterSnapshotError {
RestoreFromClusterSnapshotError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for RestoreFromClusterSnapshotError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for RestoreFromClusterSnapshotError {
fn description(&self) -> &str {
match *self {
RestoreFromClusterSnapshotError::AccessToSnapshotDeniedFault(ref cause) => cause,
RestoreFromClusterSnapshotError::ClusterAlreadyExistsFault(ref cause) => cause,
RestoreFromClusterSnapshotError::ClusterParameterGroupNotFoundFault(ref cause) => cause,
RestoreFromClusterSnapshotError::ClusterQuotaExceededFault(ref cause) => cause,
RestoreFromClusterSnapshotError::ClusterSecurityGroupNotFoundFault(ref cause) => cause,
RestoreFromClusterSnapshotError::ClusterSnapshotNotFoundFault(ref cause) => cause,
RestoreFromClusterSnapshotError::ClusterSubnetGroupNotFoundFault(ref cause) => cause,
RestoreFromClusterSnapshotError::DependentServiceRequestThrottlingFault(ref cause) => {
cause
}
RestoreFromClusterSnapshotError::HsmClientCertificateNotFoundFault(ref cause) => cause,
RestoreFromClusterSnapshotError::HsmConfigurationNotFoundFault(ref cause) => cause,
RestoreFromClusterSnapshotError::InsufficientClusterCapacityFault(ref cause) => cause,
RestoreFromClusterSnapshotError::InvalidClusterSnapshotStateFault(ref cause) => cause,
RestoreFromClusterSnapshotError::InvalidClusterSubnetGroupStateFault(ref cause) => {
cause
}
RestoreFromClusterSnapshotError::InvalidClusterTrackFault(ref cause) => cause,
RestoreFromClusterSnapshotError::InvalidElasticIpFault(ref cause) => cause,
RestoreFromClusterSnapshotError::InvalidRestoreFault(ref cause) => cause,
RestoreFromClusterSnapshotError::InvalidSubnet(ref cause) => cause,
RestoreFromClusterSnapshotError::InvalidVPCNetworkStateFault(ref cause) => cause,
RestoreFromClusterSnapshotError::LimitExceededFault(ref cause) => cause,
RestoreFromClusterSnapshotError::NumberOfNodesPerClusterLimitExceededFault(
ref cause,
) => cause,
RestoreFromClusterSnapshotError::NumberOfNodesQuotaExceededFault(ref cause) => cause,
RestoreFromClusterSnapshotError::UnauthorizedOperation(ref cause) => cause,
RestoreFromClusterSnapshotError::Validation(ref cause) => cause,
RestoreFromClusterSnapshotError::Credentials(ref err) => err.description(),
RestoreFromClusterSnapshotError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
RestoreFromClusterSnapshotError::ParseError(ref cause) => cause,
RestoreFromClusterSnapshotError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum RestoreTableFromClusterSnapshotError {
ClusterNotFoundFault(String),
ClusterSnapshotNotFoundFault(String),
InProgressTableRestoreQuotaExceededFault(String),
InvalidClusterSnapshotStateFault(String),
InvalidClusterStateFault(String),
InvalidTableRestoreArgumentFault(String),
UnsupportedOperationFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl RestoreTableFromClusterSnapshotError {
pub fn from_response(res: BufferedHttpResponse) -> RestoreTableFromClusterSnapshotError {
{
let reader = EventReader::new(res.body.as_slice());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"ClusterNotFound" => return RestoreTableFromClusterSnapshotError::ClusterNotFoundFault(String::from(parsed_error.message)),"ClusterSnapshotNotFound" => return RestoreTableFromClusterSnapshotError::ClusterSnapshotNotFoundFault(String::from(parsed_error.message)),"InProgressTableRestoreQuotaExceededFault" => return RestoreTableFromClusterSnapshotError::InProgressTableRestoreQuotaExceededFault(String::from(parsed_error.message)),"InvalidClusterSnapshotState" => return RestoreTableFromClusterSnapshotError::InvalidClusterSnapshotStateFault(String::from(parsed_error.message)),"InvalidClusterState" => return RestoreTableFromClusterSnapshotError::InvalidClusterStateFault(String::from(parsed_error.message)),"InvalidTableRestoreArgument" => return RestoreTableFromClusterSnapshotError::InvalidTableRestoreArgumentFault(String::from(parsed_error.message)),"UnsupportedOperation" => return RestoreTableFromClusterSnapshotError::UnsupportedOperationFault(String::from(parsed_error.message)),_ => {}
}
}
}
RestoreTableFromClusterSnapshotError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for RestoreTableFromClusterSnapshotError {
fn from(err: XmlParseError) -> RestoreTableFromClusterSnapshotError {
let XmlParseError(message) = err;
RestoreTableFromClusterSnapshotError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for RestoreTableFromClusterSnapshotError {
fn from(err: CredentialsError) -> RestoreTableFromClusterSnapshotError {
RestoreTableFromClusterSnapshotError::Credentials(err)
}
}
impl From<HttpDispatchError> for RestoreTableFromClusterSnapshotError {
fn from(err: HttpDispatchError) -> RestoreTableFromClusterSnapshotError {
RestoreTableFromClusterSnapshotError::HttpDispatch(err)
}
}
impl From<io::Error> for RestoreTableFromClusterSnapshotError {
fn from(err: io::Error) -> RestoreTableFromClusterSnapshotError {
RestoreTableFromClusterSnapshotError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for RestoreTableFromClusterSnapshotError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for RestoreTableFromClusterSnapshotError {
fn description(&self) -> &str {
match *self {
RestoreTableFromClusterSnapshotError::ClusterNotFoundFault(ref cause) => cause,
RestoreTableFromClusterSnapshotError::ClusterSnapshotNotFoundFault(ref cause) => cause,
RestoreTableFromClusterSnapshotError::InProgressTableRestoreQuotaExceededFault(
ref cause,
) => cause,
RestoreTableFromClusterSnapshotError::InvalidClusterSnapshotStateFault(ref cause) => {
cause
}
RestoreTableFromClusterSnapshotError::InvalidClusterStateFault(ref cause) => cause,
RestoreTableFromClusterSnapshotError::InvalidTableRestoreArgumentFault(ref cause) => {
cause
}
RestoreTableFromClusterSnapshotError::UnsupportedOperationFault(ref cause) => cause,
RestoreTableFromClusterSnapshotError::Validation(ref cause) => cause,
RestoreTableFromClusterSnapshotError::Credentials(ref err) => err.description(),
RestoreTableFromClusterSnapshotError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
RestoreTableFromClusterSnapshotError::ParseError(ref cause) => cause,
RestoreTableFromClusterSnapshotError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum RevokeClusterSecurityGroupIngressError {
AuthorizationNotFoundFault(String),
ClusterSecurityGroupNotFoundFault(String),
InvalidClusterSecurityGroupStateFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl RevokeClusterSecurityGroupIngressError {
pub fn from_response(res: BufferedHttpResponse) -> RevokeClusterSecurityGroupIngressError {
{
let reader = EventReader::new(res.body.as_slice());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"AuthorizationNotFound" => return RevokeClusterSecurityGroupIngressError::AuthorizationNotFoundFault(String::from(parsed_error.message)),"ClusterSecurityGroupNotFound" => return RevokeClusterSecurityGroupIngressError::ClusterSecurityGroupNotFoundFault(String::from(parsed_error.message)),"InvalidClusterSecurityGroupState" => return RevokeClusterSecurityGroupIngressError::InvalidClusterSecurityGroupStateFault(String::from(parsed_error.message)),_ => {}
}
}
}
RevokeClusterSecurityGroupIngressError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for RevokeClusterSecurityGroupIngressError {
fn from(err: XmlParseError) -> RevokeClusterSecurityGroupIngressError {
let XmlParseError(message) = err;
RevokeClusterSecurityGroupIngressError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for RevokeClusterSecurityGroupIngressError {
fn from(err: CredentialsError) -> RevokeClusterSecurityGroupIngressError {
RevokeClusterSecurityGroupIngressError::Credentials(err)
}
}
impl From<HttpDispatchError> for RevokeClusterSecurityGroupIngressError {
fn from(err: HttpDispatchError) -> RevokeClusterSecurityGroupIngressError {
RevokeClusterSecurityGroupIngressError::HttpDispatch(err)
}
}
impl From<io::Error> for RevokeClusterSecurityGroupIngressError {
fn from(err: io::Error) -> RevokeClusterSecurityGroupIngressError {
RevokeClusterSecurityGroupIngressError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for RevokeClusterSecurityGroupIngressError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for RevokeClusterSecurityGroupIngressError {
fn description(&self) -> &str {
match *self {
RevokeClusterSecurityGroupIngressError::AuthorizationNotFoundFault(ref cause) => cause,
RevokeClusterSecurityGroupIngressError::ClusterSecurityGroupNotFoundFault(
ref cause,
) => cause,
RevokeClusterSecurityGroupIngressError::InvalidClusterSecurityGroupStateFault(
ref cause,
) => cause,
RevokeClusterSecurityGroupIngressError::Validation(ref cause) => cause,
RevokeClusterSecurityGroupIngressError::Credentials(ref err) => err.description(),
RevokeClusterSecurityGroupIngressError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
RevokeClusterSecurityGroupIngressError::ParseError(ref cause) => cause,
RevokeClusterSecurityGroupIngressError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum RevokeSnapshotAccessError {
AccessToSnapshotDeniedFault(String),
AuthorizationNotFoundFault(String),
ClusterSnapshotNotFoundFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl RevokeSnapshotAccessError {
pub fn from_response(res: BufferedHttpResponse) -> RevokeSnapshotAccessError {
{
let reader = EventReader::new(res.body.as_slice());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"AccessToSnapshotDenied" => {
return RevokeSnapshotAccessError::AccessToSnapshotDeniedFault(String::from(
parsed_error.message,
))
}
"AuthorizationNotFound" => {
return RevokeSnapshotAccessError::AuthorizationNotFoundFault(String::from(
parsed_error.message,
))
}
"ClusterSnapshotNotFound" => {
return RevokeSnapshotAccessError::ClusterSnapshotNotFoundFault(
String::from(parsed_error.message),
)
}
_ => {}
}
}
}
RevokeSnapshotAccessError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for RevokeSnapshotAccessError {
fn from(err: XmlParseError) -> RevokeSnapshotAccessError {
let XmlParseError(message) = err;
RevokeSnapshotAccessError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for RevokeSnapshotAccessError {
fn from(err: CredentialsError) -> RevokeSnapshotAccessError {
RevokeSnapshotAccessError::Credentials(err)
}
}
impl From<HttpDispatchError> for RevokeSnapshotAccessError {
fn from(err: HttpDispatchError) -> RevokeSnapshotAccessError {
RevokeSnapshotAccessError::HttpDispatch(err)
}
}
impl From<io::Error> for RevokeSnapshotAccessError {
fn from(err: io::Error) -> RevokeSnapshotAccessError {
RevokeSnapshotAccessError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for RevokeSnapshotAccessError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for RevokeSnapshotAccessError {
fn description(&self) -> &str {
match *self {
RevokeSnapshotAccessError::AccessToSnapshotDeniedFault(ref cause) => cause,
RevokeSnapshotAccessError::AuthorizationNotFoundFault(ref cause) => cause,
RevokeSnapshotAccessError::ClusterSnapshotNotFoundFault(ref cause) => cause,
RevokeSnapshotAccessError::Validation(ref cause) => cause,
RevokeSnapshotAccessError::Credentials(ref err) => err.description(),
RevokeSnapshotAccessError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
RevokeSnapshotAccessError::ParseError(ref cause) => cause,
RevokeSnapshotAccessError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum RotateEncryptionKeyError {
ClusterNotFoundFault(String),
DependentServiceRequestThrottlingFault(String),
InvalidClusterStateFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl RotateEncryptionKeyError {
pub fn from_response(res: BufferedHttpResponse) -> RotateEncryptionKeyError {
{
let reader = EventReader::new(res.body.as_slice());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"ClusterNotFound" => {
return RotateEncryptionKeyError::ClusterNotFoundFault(String::from(
parsed_error.message,
))
}
"DependentServiceRequestThrottlingFault" => {
return RotateEncryptionKeyError::DependentServiceRequestThrottlingFault(
String::from(parsed_error.message),
)
}
"InvalidClusterState" => {
return RotateEncryptionKeyError::InvalidClusterStateFault(String::from(
parsed_error.message,
))
}
_ => {}
}
}
}
RotateEncryptionKeyError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for RotateEncryptionKeyError {
fn from(err: XmlParseError) -> RotateEncryptionKeyError {
let XmlParseError(message) = err;
RotateEncryptionKeyError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for RotateEncryptionKeyError {
fn from(err: CredentialsError) -> RotateEncryptionKeyError {
RotateEncryptionKeyError::Credentials(err)
}
}
impl From<HttpDispatchError> for RotateEncryptionKeyError {
fn from(err: HttpDispatchError) -> RotateEncryptionKeyError {
RotateEncryptionKeyError::HttpDispatch(err)
}
}
impl From<io::Error> for RotateEncryptionKeyError {
fn from(err: io::Error) -> RotateEncryptionKeyError {
RotateEncryptionKeyError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for RotateEncryptionKeyError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for RotateEncryptionKeyError {
fn description(&self) -> &str {
match *self {
RotateEncryptionKeyError::ClusterNotFoundFault(ref cause) => cause,
RotateEncryptionKeyError::DependentServiceRequestThrottlingFault(ref cause) => cause,
RotateEncryptionKeyError::InvalidClusterStateFault(ref cause) => cause,
RotateEncryptionKeyError::Validation(ref cause) => cause,
RotateEncryptionKeyError::Credentials(ref err) => err.description(),
RotateEncryptionKeyError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
RotateEncryptionKeyError::ParseError(ref cause) => cause,
RotateEncryptionKeyError::Unknown(_) => "unknown error",
}
}
}
pub trait Redshift {
fn accept_reserved_node_exchange(
&self,
input: AcceptReservedNodeExchangeInputMessage,
) -> RusotoFuture<AcceptReservedNodeExchangeOutputMessage, AcceptReservedNodeExchangeError>;
fn authorize_cluster_security_group_ingress(
&self,
input: AuthorizeClusterSecurityGroupIngressMessage,
) -> RusotoFuture<
AuthorizeClusterSecurityGroupIngressResult,
AuthorizeClusterSecurityGroupIngressError,
>;
fn authorize_snapshot_access(
&self,
input: AuthorizeSnapshotAccessMessage,
) -> RusotoFuture<AuthorizeSnapshotAccessResult, AuthorizeSnapshotAccessError>;
fn copy_cluster_snapshot(
&self,
input: CopyClusterSnapshotMessage,
) -> RusotoFuture<CopyClusterSnapshotResult, CopyClusterSnapshotError>;
fn create_cluster(
&self,
input: CreateClusterMessage,
) -> RusotoFuture<CreateClusterResult, CreateClusterError>;
fn create_cluster_parameter_group(
&self,
input: CreateClusterParameterGroupMessage,
) -> RusotoFuture<CreateClusterParameterGroupResult, CreateClusterParameterGroupError>;
fn create_cluster_security_group(
&self,
input: CreateClusterSecurityGroupMessage,
) -> RusotoFuture<CreateClusterSecurityGroupResult, CreateClusterSecurityGroupError>;
fn create_cluster_snapshot(
&self,
input: CreateClusterSnapshotMessage,
) -> RusotoFuture<CreateClusterSnapshotResult, CreateClusterSnapshotError>;
fn create_cluster_subnet_group(
&self,
input: CreateClusterSubnetGroupMessage,
) -> RusotoFuture<CreateClusterSubnetGroupResult, CreateClusterSubnetGroupError>;
fn create_event_subscription(
&self,
input: CreateEventSubscriptionMessage,
) -> RusotoFuture<CreateEventSubscriptionResult, CreateEventSubscriptionError>;
fn create_hsm_client_certificate(
&self,
input: CreateHsmClientCertificateMessage,
) -> RusotoFuture<CreateHsmClientCertificateResult, CreateHsmClientCertificateError>;
fn create_hsm_configuration(
&self,
input: CreateHsmConfigurationMessage,
) -> RusotoFuture<CreateHsmConfigurationResult, CreateHsmConfigurationError>;
fn create_snapshot_copy_grant(
&self,
input: CreateSnapshotCopyGrantMessage,
) -> RusotoFuture<CreateSnapshotCopyGrantResult, CreateSnapshotCopyGrantError>;
fn create_tags(&self, input: CreateTagsMessage) -> RusotoFuture<(), CreateTagsError>;
fn delete_cluster(
&self,
input: DeleteClusterMessage,
) -> RusotoFuture<DeleteClusterResult, DeleteClusterError>;
fn delete_cluster_parameter_group(
&self,
input: DeleteClusterParameterGroupMessage,
) -> RusotoFuture<(), DeleteClusterParameterGroupError>;
fn delete_cluster_security_group(
&self,
input: DeleteClusterSecurityGroupMessage,
) -> RusotoFuture<(), DeleteClusterSecurityGroupError>;
fn delete_cluster_snapshot(
&self,
input: DeleteClusterSnapshotMessage,
) -> RusotoFuture<DeleteClusterSnapshotResult, DeleteClusterSnapshotError>;
fn delete_cluster_subnet_group(
&self,
input: DeleteClusterSubnetGroupMessage,
) -> RusotoFuture<(), DeleteClusterSubnetGroupError>;
fn delete_event_subscription(
&self,
input: DeleteEventSubscriptionMessage,
) -> RusotoFuture<(), DeleteEventSubscriptionError>;
fn delete_hsm_client_certificate(
&self,
input: DeleteHsmClientCertificateMessage,
) -> RusotoFuture<(), DeleteHsmClientCertificateError>;
fn delete_hsm_configuration(
&self,
input: DeleteHsmConfigurationMessage,
) -> RusotoFuture<(), DeleteHsmConfigurationError>;
fn delete_snapshot_copy_grant(
&self,
input: DeleteSnapshotCopyGrantMessage,
) -> RusotoFuture<(), DeleteSnapshotCopyGrantError>;
fn delete_tags(&self, input: DeleteTagsMessage) -> RusotoFuture<(), DeleteTagsError>;
fn describe_cluster_db_revisions(
&self,
input: DescribeClusterDbRevisionsMessage,
) -> RusotoFuture<ClusterDbRevisionsMessage, DescribeClusterDbRevisionsError>;
fn describe_cluster_parameter_groups(
&self,
input: DescribeClusterParameterGroupsMessage,
) -> RusotoFuture<ClusterParameterGroupsMessage, DescribeClusterParameterGroupsError>;
fn describe_cluster_parameters(
&self,
input: DescribeClusterParametersMessage,
) -> RusotoFuture<ClusterParameterGroupDetails, DescribeClusterParametersError>;
fn describe_cluster_security_groups(
&self,
input: DescribeClusterSecurityGroupsMessage,
) -> RusotoFuture<ClusterSecurityGroupMessage, DescribeClusterSecurityGroupsError>;
fn describe_cluster_snapshots(
&self,
input: DescribeClusterSnapshotsMessage,
) -> RusotoFuture<SnapshotMessage, DescribeClusterSnapshotsError>;
fn describe_cluster_subnet_groups(
&self,
input: DescribeClusterSubnetGroupsMessage,
) -> RusotoFuture<ClusterSubnetGroupMessage, DescribeClusterSubnetGroupsError>;
fn describe_cluster_tracks(
&self,
input: DescribeClusterTracksMessage,
) -> RusotoFuture<TrackListMessage, DescribeClusterTracksError>;
fn describe_cluster_versions(
&self,
input: DescribeClusterVersionsMessage,
) -> RusotoFuture<ClusterVersionsMessage, DescribeClusterVersionsError>;
fn describe_clusters(
&self,
input: DescribeClustersMessage,
) -> RusotoFuture<ClustersMessage, DescribeClustersError>;
fn describe_default_cluster_parameters(
&self,
input: DescribeDefaultClusterParametersMessage,
) -> RusotoFuture<DescribeDefaultClusterParametersResult, DescribeDefaultClusterParametersError>;
fn describe_event_categories(
&self,
input: DescribeEventCategoriesMessage,
) -> RusotoFuture<EventCategoriesMessage, DescribeEventCategoriesError>;
fn describe_event_subscriptions(
&self,
input: DescribeEventSubscriptionsMessage,
) -> RusotoFuture<EventSubscriptionsMessage, DescribeEventSubscriptionsError>;
fn describe_events(
&self,
input: DescribeEventsMessage,
) -> RusotoFuture<EventsMessage, DescribeEventsError>;
fn describe_hsm_client_certificates(
&self,
input: DescribeHsmClientCertificatesMessage,
) -> RusotoFuture<HsmClientCertificateMessage, DescribeHsmClientCertificatesError>;
fn describe_hsm_configurations(
&self,
input: DescribeHsmConfigurationsMessage,
) -> RusotoFuture<HsmConfigurationMessage, DescribeHsmConfigurationsError>;
fn describe_logging_status(
&self,
input: DescribeLoggingStatusMessage,
) -> RusotoFuture<LoggingStatus, DescribeLoggingStatusError>;
fn describe_orderable_cluster_options(
&self,
input: DescribeOrderableClusterOptionsMessage,
) -> RusotoFuture<OrderableClusterOptionsMessage, DescribeOrderableClusterOptionsError>;
fn describe_reserved_node_offerings(
&self,
input: DescribeReservedNodeOfferingsMessage,
) -> RusotoFuture<ReservedNodeOfferingsMessage, DescribeReservedNodeOfferingsError>;
fn describe_reserved_nodes(
&self,
input: DescribeReservedNodesMessage,
) -> RusotoFuture<ReservedNodesMessage, DescribeReservedNodesError>;
fn describe_resize(
&self,
input: DescribeResizeMessage,
) -> RusotoFuture<ResizeProgressMessage, DescribeResizeError>;
fn describe_snapshot_copy_grants(
&self,
input: DescribeSnapshotCopyGrantsMessage,
) -> RusotoFuture<SnapshotCopyGrantMessage, DescribeSnapshotCopyGrantsError>;
fn describe_table_restore_status(
&self,
input: DescribeTableRestoreStatusMessage,
) -> RusotoFuture<TableRestoreStatusMessage, DescribeTableRestoreStatusError>;
fn describe_tags(
&self,
input: DescribeTagsMessage,
) -> RusotoFuture<TaggedResourceListMessage, DescribeTagsError>;
fn disable_logging(
&self,
input: DisableLoggingMessage,
) -> RusotoFuture<LoggingStatus, DisableLoggingError>;
fn disable_snapshot_copy(
&self,
input: DisableSnapshotCopyMessage,
) -> RusotoFuture<DisableSnapshotCopyResult, DisableSnapshotCopyError>;
fn enable_logging(
&self,
input: EnableLoggingMessage,
) -> RusotoFuture<LoggingStatus, EnableLoggingError>;
fn enable_snapshot_copy(
&self,
input: EnableSnapshotCopyMessage,
) -> RusotoFuture<EnableSnapshotCopyResult, EnableSnapshotCopyError>;
fn get_cluster_credentials(
&self,
input: GetClusterCredentialsMessage,
) -> RusotoFuture<ClusterCredentials, GetClusterCredentialsError>;
fn get_reserved_node_exchange_offerings(
&self,
input: GetReservedNodeExchangeOfferingsInputMessage,
) -> RusotoFuture<
GetReservedNodeExchangeOfferingsOutputMessage,
GetReservedNodeExchangeOfferingsError,
>;
fn modify_cluster(
&self,
input: ModifyClusterMessage,
) -> RusotoFuture<ModifyClusterResult, ModifyClusterError>;
fn modify_cluster_db_revision(
&self,
input: ModifyClusterDbRevisionMessage,
) -> RusotoFuture<ModifyClusterDbRevisionResult, ModifyClusterDbRevisionError>;
fn modify_cluster_iam_roles(
&self,
input: ModifyClusterIamRolesMessage,
) -> RusotoFuture<ModifyClusterIamRolesResult, ModifyClusterIamRolesError>;
fn modify_cluster_parameter_group(
&self,
input: ModifyClusterParameterGroupMessage,
) -> RusotoFuture<ClusterParameterGroupNameMessage, ModifyClusterParameterGroupError>;
fn modify_cluster_subnet_group(
&self,
input: ModifyClusterSubnetGroupMessage,
) -> RusotoFuture<ModifyClusterSubnetGroupResult, ModifyClusterSubnetGroupError>;
fn modify_event_subscription(
&self,
input: ModifyEventSubscriptionMessage,
) -> RusotoFuture<ModifyEventSubscriptionResult, ModifyEventSubscriptionError>;
fn modify_snapshot_copy_retention_period(
&self,
input: ModifySnapshotCopyRetentionPeriodMessage,
) -> RusotoFuture<ModifySnapshotCopyRetentionPeriodResult, ModifySnapshotCopyRetentionPeriodError>;
fn purchase_reserved_node_offering(
&self,
input: PurchaseReservedNodeOfferingMessage,
) -> RusotoFuture<PurchaseReservedNodeOfferingResult, PurchaseReservedNodeOfferingError>;
fn reboot_cluster(
&self,
input: RebootClusterMessage,
) -> RusotoFuture<RebootClusterResult, RebootClusterError>;
fn reset_cluster_parameter_group(
&self,
input: ResetClusterParameterGroupMessage,
) -> RusotoFuture<ClusterParameterGroupNameMessage, ResetClusterParameterGroupError>;
fn restore_from_cluster_snapshot(
&self,
input: RestoreFromClusterSnapshotMessage,
) -> RusotoFuture<RestoreFromClusterSnapshotResult, RestoreFromClusterSnapshotError>;
fn restore_table_from_cluster_snapshot(
&self,
input: RestoreTableFromClusterSnapshotMessage,
) -> RusotoFuture<RestoreTableFromClusterSnapshotResult, RestoreTableFromClusterSnapshotError>;
fn revoke_cluster_security_group_ingress(
&self,
input: RevokeClusterSecurityGroupIngressMessage,
) -> RusotoFuture<RevokeClusterSecurityGroupIngressResult, RevokeClusterSecurityGroupIngressError>;
fn revoke_snapshot_access(
&self,
input: RevokeSnapshotAccessMessage,
) -> RusotoFuture<RevokeSnapshotAccessResult, RevokeSnapshotAccessError>;
fn rotate_encryption_key(
&self,
input: RotateEncryptionKeyMessage,
) -> RusotoFuture<RotateEncryptionKeyResult, RotateEncryptionKeyError>;
}
pub struct RedshiftClient {
client: Client,
region: region::Region,
}
impl RedshiftClient {
pub fn new(region: region::Region) -> RedshiftClient {
RedshiftClient {
client: Client::shared(),
region: region,
}
}
pub fn new_with<P, D>(
request_dispatcher: D,
credentials_provider: P,
region: region::Region,
) -> RedshiftClient
where
P: ProvideAwsCredentials + Send + Sync + 'static,
P::Future: Send,
D: DispatchSignedRequest + Send + Sync + 'static,
D::Future: Send,
{
RedshiftClient {
client: Client::new_with(credentials_provider, request_dispatcher),
region: region,
}
}
}
impl Redshift for RedshiftClient {
fn accept_reserved_node_exchange(
&self,
input: AcceptReservedNodeExchangeInputMessage,
) -> RusotoFuture<AcceptReservedNodeExchangeOutputMessage, AcceptReservedNodeExchangeError>
{
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let mut params = Params::new();
params.put("Action", "AcceptReservedNodeExchange");
params.put("Version", "2012-12-01");
AcceptReservedNodeExchangeInputMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(AcceptReservedNodeExchangeError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = AcceptReservedNodeExchangeOutputMessage::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = try!(peek_at_name(&mut stack));
try!(start_element(&actual_tag_name, &mut stack));
result = try!(
AcceptReservedNodeExchangeOutputMessageDeserializer::deserialize(
"AcceptReservedNodeExchangeResult",
&mut stack
)
);
skip_tree(&mut stack);
try!(end_element(&actual_tag_name, &mut stack));
}
Ok(result)
}))
})
}
fn authorize_cluster_security_group_ingress(
&self,
input: AuthorizeClusterSecurityGroupIngressMessage,
) -> RusotoFuture<
AuthorizeClusterSecurityGroupIngressResult,
AuthorizeClusterSecurityGroupIngressError,
> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let mut params = Params::new();
params.put("Action", "AuthorizeClusterSecurityGroupIngress");
params.put("Version", "2012-12-01");
AuthorizeClusterSecurityGroupIngressMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(AuthorizeClusterSecurityGroupIngressError::from_response(
response,
))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = AuthorizeClusterSecurityGroupIngressResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = try!(peek_at_name(&mut stack));
try!(start_element(&actual_tag_name, &mut stack));
result = try!(
AuthorizeClusterSecurityGroupIngressResultDeserializer::deserialize(
"AuthorizeClusterSecurityGroupIngressResult",
&mut stack
)
);
skip_tree(&mut stack);
try!(end_element(&actual_tag_name, &mut stack));
}
Ok(result)
}))
})
}
fn authorize_snapshot_access(
&self,
input: AuthorizeSnapshotAccessMessage,
) -> RusotoFuture<AuthorizeSnapshotAccessResult, AuthorizeSnapshotAccessError> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let mut params = Params::new();
params.put("Action", "AuthorizeSnapshotAccess");
params.put("Version", "2012-12-01");
AuthorizeSnapshotAccessMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(AuthorizeSnapshotAccessError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = AuthorizeSnapshotAccessResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = try!(peek_at_name(&mut stack));
try!(start_element(&actual_tag_name, &mut stack));
result = try!(AuthorizeSnapshotAccessResultDeserializer::deserialize(
"AuthorizeSnapshotAccessResult",
&mut stack
));
skip_tree(&mut stack);
try!(end_element(&actual_tag_name, &mut stack));
}
Ok(result)
}))
})
}
fn copy_cluster_snapshot(
&self,
input: CopyClusterSnapshotMessage,
) -> RusotoFuture<CopyClusterSnapshotResult, CopyClusterSnapshotError> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let mut params = Params::new();
params.put("Action", "CopyClusterSnapshot");
params.put("Version", "2012-12-01");
CopyClusterSnapshotMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response.buffer().from_err().and_then(|response| {
Err(CopyClusterSnapshotError::from_response(response))
}),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = CopyClusterSnapshotResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = try!(peek_at_name(&mut stack));
try!(start_element(&actual_tag_name, &mut stack));
result = try!(CopyClusterSnapshotResultDeserializer::deserialize(
"CopyClusterSnapshotResult",
&mut stack
));
skip_tree(&mut stack);
try!(end_element(&actual_tag_name, &mut stack));
}
Ok(result)
}))
})
}
fn create_cluster(
&self,
input: CreateClusterMessage,
) -> RusotoFuture<CreateClusterResult, CreateClusterError> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let mut params = Params::new();
params.put("Action", "CreateCluster");
params.put("Version", "2012-12-01");
CreateClusterMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(CreateClusterError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = CreateClusterResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = try!(peek_at_name(&mut stack));
try!(start_element(&actual_tag_name, &mut stack));
result = try!(CreateClusterResultDeserializer::deserialize(
"CreateClusterResult",
&mut stack
));
skip_tree(&mut stack);
try!(end_element(&actual_tag_name, &mut stack));
}
Ok(result)
}))
})
}
fn create_cluster_parameter_group(
&self,
input: CreateClusterParameterGroupMessage,
) -> RusotoFuture<CreateClusterParameterGroupResult, CreateClusterParameterGroupError> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let mut params = Params::new();
params.put("Action", "CreateClusterParameterGroup");
params.put("Version", "2012-12-01");
CreateClusterParameterGroupMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(CreateClusterParameterGroupError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = CreateClusterParameterGroupResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = try!(peek_at_name(&mut stack));
try!(start_element(&actual_tag_name, &mut stack));
result = try!(CreateClusterParameterGroupResultDeserializer::deserialize(
"CreateClusterParameterGroupResult",
&mut stack
));
skip_tree(&mut stack);
try!(end_element(&actual_tag_name, &mut stack));
}
Ok(result)
}))
})
}
fn create_cluster_security_group(
&self,
input: CreateClusterSecurityGroupMessage,
) -> RusotoFuture<CreateClusterSecurityGroupResult, CreateClusterSecurityGroupError> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let mut params = Params::new();
params.put("Action", "CreateClusterSecurityGroup");
params.put("Version", "2012-12-01");
CreateClusterSecurityGroupMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(CreateClusterSecurityGroupError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = CreateClusterSecurityGroupResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = try!(peek_at_name(&mut stack));
try!(start_element(&actual_tag_name, &mut stack));
result = try!(CreateClusterSecurityGroupResultDeserializer::deserialize(
"CreateClusterSecurityGroupResult",
&mut stack
));
skip_tree(&mut stack);
try!(end_element(&actual_tag_name, &mut stack));
}
Ok(result)
}))
})
}
fn create_cluster_snapshot(
&self,
input: CreateClusterSnapshotMessage,
) -> RusotoFuture<CreateClusterSnapshotResult, CreateClusterSnapshotError> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let mut params = Params::new();
params.put("Action", "CreateClusterSnapshot");
params.put("Version", "2012-12-01");
CreateClusterSnapshotMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response.buffer().from_err().and_then(|response| {
Err(CreateClusterSnapshotError::from_response(response))
}),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = CreateClusterSnapshotResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = try!(peek_at_name(&mut stack));
try!(start_element(&actual_tag_name, &mut stack));
result = try!(CreateClusterSnapshotResultDeserializer::deserialize(
"CreateClusterSnapshotResult",
&mut stack
));
skip_tree(&mut stack);
try!(end_element(&actual_tag_name, &mut stack));
}
Ok(result)
}))
})
}
fn create_cluster_subnet_group(
&self,
input: CreateClusterSubnetGroupMessage,
) -> RusotoFuture<CreateClusterSubnetGroupResult, CreateClusterSubnetGroupError> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let mut params = Params::new();
params.put("Action", "CreateClusterSubnetGroup");
params.put("Version", "2012-12-01");
CreateClusterSubnetGroupMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(CreateClusterSubnetGroupError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = CreateClusterSubnetGroupResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = try!(peek_at_name(&mut stack));
try!(start_element(&actual_tag_name, &mut stack));
result = try!(CreateClusterSubnetGroupResultDeserializer::deserialize(
"CreateClusterSubnetGroupResult",
&mut stack
));
skip_tree(&mut stack);
try!(end_element(&actual_tag_name, &mut stack));
}
Ok(result)
}))
})
}
fn create_event_subscription(
&self,
input: CreateEventSubscriptionMessage,
) -> RusotoFuture<CreateEventSubscriptionResult, CreateEventSubscriptionError> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let mut params = Params::new();
params.put("Action", "CreateEventSubscription");
params.put("Version", "2012-12-01");
CreateEventSubscriptionMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(CreateEventSubscriptionError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = CreateEventSubscriptionResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = try!(peek_at_name(&mut stack));
try!(start_element(&actual_tag_name, &mut stack));
result = try!(CreateEventSubscriptionResultDeserializer::deserialize(
"CreateEventSubscriptionResult",
&mut stack
));
skip_tree(&mut stack);
try!(end_element(&actual_tag_name, &mut stack));
}
Ok(result)
}))
})
}
fn create_hsm_client_certificate(
&self,
input: CreateHsmClientCertificateMessage,
) -> RusotoFuture<CreateHsmClientCertificateResult, CreateHsmClientCertificateError> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let mut params = Params::new();
params.put("Action", "CreateHsmClientCertificate");
params.put("Version", "2012-12-01");
CreateHsmClientCertificateMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(CreateHsmClientCertificateError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = CreateHsmClientCertificateResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = try!(peek_at_name(&mut stack));
try!(start_element(&actual_tag_name, &mut stack));
result = try!(CreateHsmClientCertificateResultDeserializer::deserialize(
"CreateHsmClientCertificateResult",
&mut stack
));
skip_tree(&mut stack);
try!(end_element(&actual_tag_name, &mut stack));
}
Ok(result)
}))
})
}
fn create_hsm_configuration(
&self,
input: CreateHsmConfigurationMessage,
) -> RusotoFuture<CreateHsmConfigurationResult, CreateHsmConfigurationError> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let mut params = Params::new();
params.put("Action", "CreateHsmConfiguration");
params.put("Version", "2012-12-01");
CreateHsmConfigurationMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(CreateHsmConfigurationError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = CreateHsmConfigurationResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = try!(peek_at_name(&mut stack));
try!(start_element(&actual_tag_name, &mut stack));
result = try!(CreateHsmConfigurationResultDeserializer::deserialize(
"CreateHsmConfigurationResult",
&mut stack
));
skip_tree(&mut stack);
try!(end_element(&actual_tag_name, &mut stack));
}
Ok(result)
}))
})
}
fn create_snapshot_copy_grant(
&self,
input: CreateSnapshotCopyGrantMessage,
) -> RusotoFuture<CreateSnapshotCopyGrantResult, CreateSnapshotCopyGrantError> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let mut params = Params::new();
params.put("Action", "CreateSnapshotCopyGrant");
params.put("Version", "2012-12-01");
CreateSnapshotCopyGrantMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(CreateSnapshotCopyGrantError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = CreateSnapshotCopyGrantResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = try!(peek_at_name(&mut stack));
try!(start_element(&actual_tag_name, &mut stack));
result = try!(CreateSnapshotCopyGrantResultDeserializer::deserialize(
"CreateSnapshotCopyGrantResult",
&mut stack
));
skip_tree(&mut stack);
try!(end_element(&actual_tag_name, &mut stack));
}
Ok(result)
}))
})
}
fn create_tags(&self, input: CreateTagsMessage) -> RusotoFuture<(), CreateTagsError> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let mut params = Params::new();
params.put("Action", "CreateTags");
params.put("Version", "2012-12-01");
CreateTagsMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(CreateTagsError::from_response(response))),
);
}
Box::new(future::ok(::std::mem::drop(response)))
})
}
fn delete_cluster(
&self,
input: DeleteClusterMessage,
) -> RusotoFuture<DeleteClusterResult, DeleteClusterError> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DeleteCluster");
params.put("Version", "2012-12-01");
DeleteClusterMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DeleteClusterError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DeleteClusterResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = try!(peek_at_name(&mut stack));
try!(start_element(&actual_tag_name, &mut stack));
result = try!(DeleteClusterResultDeserializer::deserialize(
"DeleteClusterResult",
&mut stack
));
skip_tree(&mut stack);
try!(end_element(&actual_tag_name, &mut stack));
}
Ok(result)
}))
})
}
fn delete_cluster_parameter_group(
&self,
input: DeleteClusterParameterGroupMessage,
) -> RusotoFuture<(), DeleteClusterParameterGroupError> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DeleteClusterParameterGroup");
params.put("Version", "2012-12-01");
DeleteClusterParameterGroupMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DeleteClusterParameterGroupError::from_response(response))
}));
}
Box::new(future::ok(::std::mem::drop(response)))
})
}
fn delete_cluster_security_group(
&self,
input: DeleteClusterSecurityGroupMessage,
) -> RusotoFuture<(), DeleteClusterSecurityGroupError> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DeleteClusterSecurityGroup");
params.put("Version", "2012-12-01");
DeleteClusterSecurityGroupMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DeleteClusterSecurityGroupError::from_response(response))
}));
}
Box::new(future::ok(::std::mem::drop(response)))
})
}
fn delete_cluster_snapshot(
&self,
input: DeleteClusterSnapshotMessage,
) -> RusotoFuture<DeleteClusterSnapshotResult, DeleteClusterSnapshotError> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DeleteClusterSnapshot");
params.put("Version", "2012-12-01");
DeleteClusterSnapshotMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response.buffer().from_err().and_then(|response| {
Err(DeleteClusterSnapshotError::from_response(response))
}),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DeleteClusterSnapshotResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = try!(peek_at_name(&mut stack));
try!(start_element(&actual_tag_name, &mut stack));
result = try!(DeleteClusterSnapshotResultDeserializer::deserialize(
"DeleteClusterSnapshotResult",
&mut stack
));
skip_tree(&mut stack);
try!(end_element(&actual_tag_name, &mut stack));
}
Ok(result)
}))
})
}
fn delete_cluster_subnet_group(
&self,
input: DeleteClusterSubnetGroupMessage,
) -> RusotoFuture<(), DeleteClusterSubnetGroupError> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DeleteClusterSubnetGroup");
params.put("Version", "2012-12-01");
DeleteClusterSubnetGroupMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DeleteClusterSubnetGroupError::from_response(response))
}));
}
Box::new(future::ok(::std::mem::drop(response)))
})
}
fn delete_event_subscription(
&self,
input: DeleteEventSubscriptionMessage,
) -> RusotoFuture<(), DeleteEventSubscriptionError> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DeleteEventSubscription");
params.put("Version", "2012-12-01");
DeleteEventSubscriptionMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DeleteEventSubscriptionError::from_response(response))
}));
}
Box::new(future::ok(::std::mem::drop(response)))
})
}
fn delete_hsm_client_certificate(
&self,
input: DeleteHsmClientCertificateMessage,
) -> RusotoFuture<(), DeleteHsmClientCertificateError> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DeleteHsmClientCertificate");
params.put("Version", "2012-12-01");
DeleteHsmClientCertificateMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DeleteHsmClientCertificateError::from_response(response))
}));
}
Box::new(future::ok(::std::mem::drop(response)))
})
}
fn delete_hsm_configuration(
&self,
input: DeleteHsmConfigurationMessage,
) -> RusotoFuture<(), DeleteHsmConfigurationError> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DeleteHsmConfiguration");
params.put("Version", "2012-12-01");
DeleteHsmConfigurationMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DeleteHsmConfigurationError::from_response(response))
}));
}
Box::new(future::ok(::std::mem::drop(response)))
})
}
fn delete_snapshot_copy_grant(
&self,
input: DeleteSnapshotCopyGrantMessage,
) -> RusotoFuture<(), DeleteSnapshotCopyGrantError> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DeleteSnapshotCopyGrant");
params.put("Version", "2012-12-01");
DeleteSnapshotCopyGrantMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DeleteSnapshotCopyGrantError::from_response(response))
}));
}
Box::new(future::ok(::std::mem::drop(response)))
})
}
fn delete_tags(&self, input: DeleteTagsMessage) -> RusotoFuture<(), DeleteTagsError> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DeleteTags");
params.put("Version", "2012-12-01");
DeleteTagsMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DeleteTagsError::from_response(response))),
);
}
Box::new(future::ok(::std::mem::drop(response)))
})
}
fn describe_cluster_db_revisions(
&self,
input: DescribeClusterDbRevisionsMessage,
) -> RusotoFuture<ClusterDbRevisionsMessage, DescribeClusterDbRevisionsError> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeClusterDbRevisions");
params.put("Version", "2012-12-01");
DescribeClusterDbRevisionsMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeClusterDbRevisionsError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = ClusterDbRevisionsMessage::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = try!(peek_at_name(&mut stack));
try!(start_element(&actual_tag_name, &mut stack));
result = try!(ClusterDbRevisionsMessageDeserializer::deserialize(
"DescribeClusterDbRevisionsResult",
&mut stack
));
skip_tree(&mut stack);
try!(end_element(&actual_tag_name, &mut stack));
}
Ok(result)
}))
})
}
fn describe_cluster_parameter_groups(
&self,
input: DescribeClusterParameterGroupsMessage,
) -> RusotoFuture<ClusterParameterGroupsMessage, DescribeClusterParameterGroupsError> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeClusterParameterGroups");
params.put("Version", "2012-12-01");
DescribeClusterParameterGroupsMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeClusterParameterGroupsError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = ClusterParameterGroupsMessage::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = try!(peek_at_name(&mut stack));
try!(start_element(&actual_tag_name, &mut stack));
result = try!(ClusterParameterGroupsMessageDeserializer::deserialize(
"DescribeClusterParameterGroupsResult",
&mut stack
));
skip_tree(&mut stack);
try!(end_element(&actual_tag_name, &mut stack));
}
Ok(result)
}))
})
}
fn describe_cluster_parameters(
&self,
input: DescribeClusterParametersMessage,
) -> RusotoFuture<ClusterParameterGroupDetails, DescribeClusterParametersError> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeClusterParameters");
params.put("Version", "2012-12-01");
DescribeClusterParametersMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeClusterParametersError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = ClusterParameterGroupDetails::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = try!(peek_at_name(&mut stack));
try!(start_element(&actual_tag_name, &mut stack));
result = try!(ClusterParameterGroupDetailsDeserializer::deserialize(
"DescribeClusterParametersResult",
&mut stack
));
skip_tree(&mut stack);
try!(end_element(&actual_tag_name, &mut stack));
}
Ok(result)
}))
})
}
fn describe_cluster_security_groups(
&self,
input: DescribeClusterSecurityGroupsMessage,
) -> RusotoFuture<ClusterSecurityGroupMessage, DescribeClusterSecurityGroupsError> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeClusterSecurityGroups");
params.put("Version", "2012-12-01");
DescribeClusterSecurityGroupsMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeClusterSecurityGroupsError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = ClusterSecurityGroupMessage::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = try!(peek_at_name(&mut stack));
try!(start_element(&actual_tag_name, &mut stack));
result = try!(ClusterSecurityGroupMessageDeserializer::deserialize(
"DescribeClusterSecurityGroupsResult",
&mut stack
));
skip_tree(&mut stack);
try!(end_element(&actual_tag_name, &mut stack));
}
Ok(result)
}))
})
}
fn describe_cluster_snapshots(
&self,
input: DescribeClusterSnapshotsMessage,
) -> RusotoFuture<SnapshotMessage, DescribeClusterSnapshotsError> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeClusterSnapshots");
params.put("Version", "2012-12-01");
DescribeClusterSnapshotsMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeClusterSnapshotsError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = SnapshotMessage::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = try!(peek_at_name(&mut stack));
try!(start_element(&actual_tag_name, &mut stack));
result = try!(SnapshotMessageDeserializer::deserialize(
"DescribeClusterSnapshotsResult",
&mut stack
));
skip_tree(&mut stack);
try!(end_element(&actual_tag_name, &mut stack));
}
Ok(result)
}))
})
}
fn describe_cluster_subnet_groups(
&self,
input: DescribeClusterSubnetGroupsMessage,
) -> RusotoFuture<ClusterSubnetGroupMessage, DescribeClusterSubnetGroupsError> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeClusterSubnetGroups");
params.put("Version", "2012-12-01");
DescribeClusterSubnetGroupsMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeClusterSubnetGroupsError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = ClusterSubnetGroupMessage::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = try!(peek_at_name(&mut stack));
try!(start_element(&actual_tag_name, &mut stack));
result = try!(ClusterSubnetGroupMessageDeserializer::deserialize(
"DescribeClusterSubnetGroupsResult",
&mut stack
));
skip_tree(&mut stack);
try!(end_element(&actual_tag_name, &mut stack));
}
Ok(result)
}))
})
}
fn describe_cluster_tracks(
&self,
input: DescribeClusterTracksMessage,
) -> RusotoFuture<TrackListMessage, DescribeClusterTracksError> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeClusterTracks");
params.put("Version", "2012-12-01");
DescribeClusterTracksMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response.buffer().from_err().and_then(|response| {
Err(DescribeClusterTracksError::from_response(response))
}),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = TrackListMessage::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = try!(peek_at_name(&mut stack));
try!(start_element(&actual_tag_name, &mut stack));
result = try!(TrackListMessageDeserializer::deserialize(
"DescribeClusterTracksResult",
&mut stack
));
skip_tree(&mut stack);
try!(end_element(&actual_tag_name, &mut stack));
}
Ok(result)
}))
})
}
fn describe_cluster_versions(
&self,
input: DescribeClusterVersionsMessage,
) -> RusotoFuture<ClusterVersionsMessage, DescribeClusterVersionsError> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeClusterVersions");
params.put("Version", "2012-12-01");
DescribeClusterVersionsMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeClusterVersionsError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = ClusterVersionsMessage::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = try!(peek_at_name(&mut stack));
try!(start_element(&actual_tag_name, &mut stack));
result = try!(ClusterVersionsMessageDeserializer::deserialize(
"DescribeClusterVersionsResult",
&mut stack
));
skip_tree(&mut stack);
try!(end_element(&actual_tag_name, &mut stack));
}
Ok(result)
}))
})
}
fn describe_clusters(
&self,
input: DescribeClustersMessage,
) -> RusotoFuture<ClustersMessage, DescribeClustersError> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeClusters");
params.put("Version", "2012-12-01");
DescribeClustersMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DescribeClustersError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = ClustersMessage::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = try!(peek_at_name(&mut stack));
try!(start_element(&actual_tag_name, &mut stack));
result = try!(ClustersMessageDeserializer::deserialize(
"DescribeClustersResult",
&mut stack
));
skip_tree(&mut stack);
try!(end_element(&actual_tag_name, &mut stack));
}
Ok(result)
}))
})
}
fn describe_default_cluster_parameters(
&self,
input: DescribeDefaultClusterParametersMessage,
) -> RusotoFuture<DescribeDefaultClusterParametersResult, DescribeDefaultClusterParametersError>
{
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeDefaultClusterParameters");
params.put("Version", "2012-12-01");
DescribeDefaultClusterParametersMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeDefaultClusterParametersError::from_response(
response,
))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeDefaultClusterParametersResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = try!(peek_at_name(&mut stack));
try!(start_element(&actual_tag_name, &mut stack));
result = try!(
DescribeDefaultClusterParametersResultDeserializer::deserialize(
"DescribeDefaultClusterParametersResult",
&mut stack
)
);
skip_tree(&mut stack);
try!(end_element(&actual_tag_name, &mut stack));
}
Ok(result)
}))
})
}
fn describe_event_categories(
&self,
input: DescribeEventCategoriesMessage,
) -> RusotoFuture<EventCategoriesMessage, DescribeEventCategoriesError> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeEventCategories");
params.put("Version", "2012-12-01");
DescribeEventCategoriesMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeEventCategoriesError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = EventCategoriesMessage::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = try!(peek_at_name(&mut stack));
try!(start_element(&actual_tag_name, &mut stack));
result = try!(EventCategoriesMessageDeserializer::deserialize(
"DescribeEventCategoriesResult",
&mut stack
));
skip_tree(&mut stack);
try!(end_element(&actual_tag_name, &mut stack));
}
Ok(result)
}))
})
}
fn describe_event_subscriptions(
&self,
input: DescribeEventSubscriptionsMessage,
) -> RusotoFuture<EventSubscriptionsMessage, DescribeEventSubscriptionsError> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeEventSubscriptions");
params.put("Version", "2012-12-01");
DescribeEventSubscriptionsMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeEventSubscriptionsError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = EventSubscriptionsMessage::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = try!(peek_at_name(&mut stack));
try!(start_element(&actual_tag_name, &mut stack));
result = try!(EventSubscriptionsMessageDeserializer::deserialize(
"DescribeEventSubscriptionsResult",
&mut stack
));
skip_tree(&mut stack);
try!(end_element(&actual_tag_name, &mut stack));
}
Ok(result)
}))
})
}
fn describe_events(
&self,
input: DescribeEventsMessage,
) -> RusotoFuture<EventsMessage, DescribeEventsError> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeEvents");
params.put("Version", "2012-12-01");
DescribeEventsMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DescribeEventsError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = EventsMessage::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = try!(peek_at_name(&mut stack));
try!(start_element(&actual_tag_name, &mut stack));
result = try!(EventsMessageDeserializer::deserialize(
"DescribeEventsResult",
&mut stack
));
skip_tree(&mut stack);
try!(end_element(&actual_tag_name, &mut stack));
}
Ok(result)
}))
})
}
fn describe_hsm_client_certificates(
&self,
input: DescribeHsmClientCertificatesMessage,
) -> RusotoFuture<HsmClientCertificateMessage, DescribeHsmClientCertificatesError> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeHsmClientCertificates");
params.put("Version", "2012-12-01");
DescribeHsmClientCertificatesMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeHsmClientCertificatesError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = HsmClientCertificateMessage::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = try!(peek_at_name(&mut stack));
try!(start_element(&actual_tag_name, &mut stack));
result = try!(HsmClientCertificateMessageDeserializer::deserialize(
"DescribeHsmClientCertificatesResult",
&mut stack
));
skip_tree(&mut stack);
try!(end_element(&actual_tag_name, &mut stack));
}
Ok(result)
}))
})
}
fn describe_hsm_configurations(
&self,
input: DescribeHsmConfigurationsMessage,
) -> RusotoFuture<HsmConfigurationMessage, DescribeHsmConfigurationsError> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeHsmConfigurations");
params.put("Version", "2012-12-01");
DescribeHsmConfigurationsMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeHsmConfigurationsError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = HsmConfigurationMessage::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = try!(peek_at_name(&mut stack));
try!(start_element(&actual_tag_name, &mut stack));
result = try!(HsmConfigurationMessageDeserializer::deserialize(
"DescribeHsmConfigurationsResult",
&mut stack
));
skip_tree(&mut stack);
try!(end_element(&actual_tag_name, &mut stack));
}
Ok(result)
}))
})
}
fn describe_logging_status(
&self,
input: DescribeLoggingStatusMessage,
) -> RusotoFuture<LoggingStatus, DescribeLoggingStatusError> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeLoggingStatus");
params.put("Version", "2012-12-01");
DescribeLoggingStatusMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response.buffer().from_err().and_then(|response| {
Err(DescribeLoggingStatusError::from_response(response))
}),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = LoggingStatus::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = try!(peek_at_name(&mut stack));
try!(start_element(&actual_tag_name, &mut stack));
result = try!(LoggingStatusDeserializer::deserialize(
"DescribeLoggingStatusResult",
&mut stack
));
skip_tree(&mut stack);
try!(end_element(&actual_tag_name, &mut stack));
}
Ok(result)
}))
})
}
fn describe_orderable_cluster_options(
&self,
input: DescribeOrderableClusterOptionsMessage,
) -> RusotoFuture<OrderableClusterOptionsMessage, DescribeOrderableClusterOptionsError> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeOrderableClusterOptions");
params.put("Version", "2012-12-01");
DescribeOrderableClusterOptionsMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeOrderableClusterOptionsError::from_response(
response,
))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = OrderableClusterOptionsMessage::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = try!(peek_at_name(&mut stack));
try!(start_element(&actual_tag_name, &mut stack));
result = try!(OrderableClusterOptionsMessageDeserializer::deserialize(
"DescribeOrderableClusterOptionsResult",
&mut stack
));
skip_tree(&mut stack);
try!(end_element(&actual_tag_name, &mut stack));
}
Ok(result)
}))
})
}
fn describe_reserved_node_offerings(
&self,
input: DescribeReservedNodeOfferingsMessage,
) -> RusotoFuture<ReservedNodeOfferingsMessage, DescribeReservedNodeOfferingsError> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeReservedNodeOfferings");
params.put("Version", "2012-12-01");
DescribeReservedNodeOfferingsMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeReservedNodeOfferingsError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = ReservedNodeOfferingsMessage::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = try!(peek_at_name(&mut stack));
try!(start_element(&actual_tag_name, &mut stack));
result = try!(ReservedNodeOfferingsMessageDeserializer::deserialize(
"DescribeReservedNodeOfferingsResult",
&mut stack
));
skip_tree(&mut stack);
try!(end_element(&actual_tag_name, &mut stack));
}
Ok(result)
}))
})
}
fn describe_reserved_nodes(
&self,
input: DescribeReservedNodesMessage,
) -> RusotoFuture<ReservedNodesMessage, DescribeReservedNodesError> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeReservedNodes");
params.put("Version", "2012-12-01");
DescribeReservedNodesMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response.buffer().from_err().and_then(|response| {
Err(DescribeReservedNodesError::from_response(response))
}),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = ReservedNodesMessage::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = try!(peek_at_name(&mut stack));
try!(start_element(&actual_tag_name, &mut stack));
result = try!(ReservedNodesMessageDeserializer::deserialize(
"DescribeReservedNodesResult",
&mut stack
));
skip_tree(&mut stack);
try!(end_element(&actual_tag_name, &mut stack));
}
Ok(result)
}))
})
}
fn describe_resize(
&self,
input: DescribeResizeMessage,
) -> RusotoFuture<ResizeProgressMessage, DescribeResizeError> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeResize");
params.put("Version", "2012-12-01");
DescribeResizeMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DescribeResizeError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = ResizeProgressMessage::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = try!(peek_at_name(&mut stack));
try!(start_element(&actual_tag_name, &mut stack));
result = try!(ResizeProgressMessageDeserializer::deserialize(
"DescribeResizeResult",
&mut stack
));
skip_tree(&mut stack);
try!(end_element(&actual_tag_name, &mut stack));
}
Ok(result)
}))
})
}
fn describe_snapshot_copy_grants(
&self,
input: DescribeSnapshotCopyGrantsMessage,
) -> RusotoFuture<SnapshotCopyGrantMessage, DescribeSnapshotCopyGrantsError> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeSnapshotCopyGrants");
params.put("Version", "2012-12-01");
DescribeSnapshotCopyGrantsMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeSnapshotCopyGrantsError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = SnapshotCopyGrantMessage::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = try!(peek_at_name(&mut stack));
try!(start_element(&actual_tag_name, &mut stack));
result = try!(SnapshotCopyGrantMessageDeserializer::deserialize(
"DescribeSnapshotCopyGrantsResult",
&mut stack
));
skip_tree(&mut stack);
try!(end_element(&actual_tag_name, &mut stack));
}
Ok(result)
}))
})
}
fn describe_table_restore_status(
&self,
input: DescribeTableRestoreStatusMessage,
) -> RusotoFuture<TableRestoreStatusMessage, DescribeTableRestoreStatusError> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeTableRestoreStatus");
params.put("Version", "2012-12-01");
DescribeTableRestoreStatusMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeTableRestoreStatusError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = TableRestoreStatusMessage::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = try!(peek_at_name(&mut stack));
try!(start_element(&actual_tag_name, &mut stack));
result = try!(TableRestoreStatusMessageDeserializer::deserialize(
"DescribeTableRestoreStatusResult",
&mut stack
));
skip_tree(&mut stack);
try!(end_element(&actual_tag_name, &mut stack));
}
Ok(result)
}))
})
}
fn describe_tags(
&self,
input: DescribeTagsMessage,
) -> RusotoFuture<TaggedResourceListMessage, DescribeTagsError> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeTags");
params.put("Version", "2012-12-01");
DescribeTagsMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DescribeTagsError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = TaggedResourceListMessage::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = try!(peek_at_name(&mut stack));
try!(start_element(&actual_tag_name, &mut stack));
result = try!(TaggedResourceListMessageDeserializer::deserialize(
"DescribeTagsResult",
&mut stack
));
skip_tree(&mut stack);
try!(end_element(&actual_tag_name, &mut stack));
}
Ok(result)
}))
})
}
fn disable_logging(
&self,
input: DisableLoggingMessage,
) -> RusotoFuture<LoggingStatus, DisableLoggingError> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DisableLogging");
params.put("Version", "2012-12-01");
DisableLoggingMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DisableLoggingError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = LoggingStatus::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = try!(peek_at_name(&mut stack));
try!(start_element(&actual_tag_name, &mut stack));
result = try!(LoggingStatusDeserializer::deserialize(
"DisableLoggingResult",
&mut stack
));
skip_tree(&mut stack);
try!(end_element(&actual_tag_name, &mut stack));
}
Ok(result)
}))
})
}
fn disable_snapshot_copy(
&self,
input: DisableSnapshotCopyMessage,
) -> RusotoFuture<DisableSnapshotCopyResult, DisableSnapshotCopyError> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DisableSnapshotCopy");
params.put("Version", "2012-12-01");
DisableSnapshotCopyMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response.buffer().from_err().and_then(|response| {
Err(DisableSnapshotCopyError::from_response(response))
}),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DisableSnapshotCopyResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = try!(peek_at_name(&mut stack));
try!(start_element(&actual_tag_name, &mut stack));
result = try!(DisableSnapshotCopyResultDeserializer::deserialize(
"DisableSnapshotCopyResult",
&mut stack
));
skip_tree(&mut stack);
try!(end_element(&actual_tag_name, &mut stack));
}
Ok(result)
}))
})
}
fn enable_logging(
&self,
input: EnableLoggingMessage,
) -> RusotoFuture<LoggingStatus, EnableLoggingError> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let mut params = Params::new();
params.put("Action", "EnableLogging");
params.put("Version", "2012-12-01");
EnableLoggingMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(EnableLoggingError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = LoggingStatus::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = try!(peek_at_name(&mut stack));
try!(start_element(&actual_tag_name, &mut stack));
result = try!(LoggingStatusDeserializer::deserialize(
"EnableLoggingResult",
&mut stack
));
skip_tree(&mut stack);
try!(end_element(&actual_tag_name, &mut stack));
}
Ok(result)
}))
})
}
fn enable_snapshot_copy(
&self,
input: EnableSnapshotCopyMessage,
) -> RusotoFuture<EnableSnapshotCopyResult, EnableSnapshotCopyError> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let mut params = Params::new();
params.put("Action", "EnableSnapshotCopy");
params.put("Version", "2012-12-01");
EnableSnapshotCopyMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(EnableSnapshotCopyError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = EnableSnapshotCopyResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = try!(peek_at_name(&mut stack));
try!(start_element(&actual_tag_name, &mut stack));
result = try!(EnableSnapshotCopyResultDeserializer::deserialize(
"EnableSnapshotCopyResult",
&mut stack
));
skip_tree(&mut stack);
try!(end_element(&actual_tag_name, &mut stack));
}
Ok(result)
}))
})
}
fn get_cluster_credentials(
&self,
input: GetClusterCredentialsMessage,
) -> RusotoFuture<ClusterCredentials, GetClusterCredentialsError> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let mut params = Params::new();
params.put("Action", "GetClusterCredentials");
params.put("Version", "2012-12-01");
GetClusterCredentialsMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response.buffer().from_err().and_then(|response| {
Err(GetClusterCredentialsError::from_response(response))
}),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = ClusterCredentials::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = try!(peek_at_name(&mut stack));
try!(start_element(&actual_tag_name, &mut stack));
result = try!(ClusterCredentialsDeserializer::deserialize(
"GetClusterCredentialsResult",
&mut stack
));
skip_tree(&mut stack);
try!(end_element(&actual_tag_name, &mut stack));
}
Ok(result)
}))
})
}
fn get_reserved_node_exchange_offerings(
&self,
input: GetReservedNodeExchangeOfferingsInputMessage,
) -> RusotoFuture<
GetReservedNodeExchangeOfferingsOutputMessage,
GetReservedNodeExchangeOfferingsError,
> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let mut params = Params::new();
params.put("Action", "GetReservedNodeExchangeOfferings");
params.put("Version", "2012-12-01");
GetReservedNodeExchangeOfferingsInputMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(GetReservedNodeExchangeOfferingsError::from_response(
response,
))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = GetReservedNodeExchangeOfferingsOutputMessage::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = try!(peek_at_name(&mut stack));
try!(start_element(&actual_tag_name, &mut stack));
result = try!(
GetReservedNodeExchangeOfferingsOutputMessageDeserializer::deserialize(
"GetReservedNodeExchangeOfferingsResult",
&mut stack
)
);
skip_tree(&mut stack);
try!(end_element(&actual_tag_name, &mut stack));
}
Ok(result)
}))
})
}
fn modify_cluster(
&self,
input: ModifyClusterMessage,
) -> RusotoFuture<ModifyClusterResult, ModifyClusterError> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let mut params = Params::new();
params.put("Action", "ModifyCluster");
params.put("Version", "2012-12-01");
ModifyClusterMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(ModifyClusterError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = ModifyClusterResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = try!(peek_at_name(&mut stack));
try!(start_element(&actual_tag_name, &mut stack));
result = try!(ModifyClusterResultDeserializer::deserialize(
"ModifyClusterResult",
&mut stack
));
skip_tree(&mut stack);
try!(end_element(&actual_tag_name, &mut stack));
}
Ok(result)
}))
})
}
fn modify_cluster_db_revision(
&self,
input: ModifyClusterDbRevisionMessage,
) -> RusotoFuture<ModifyClusterDbRevisionResult, ModifyClusterDbRevisionError> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let mut params = Params::new();
params.put("Action", "ModifyClusterDbRevision");
params.put("Version", "2012-12-01");
ModifyClusterDbRevisionMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(ModifyClusterDbRevisionError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = ModifyClusterDbRevisionResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = try!(peek_at_name(&mut stack));
try!(start_element(&actual_tag_name, &mut stack));
result = try!(ModifyClusterDbRevisionResultDeserializer::deserialize(
"ModifyClusterDbRevisionResult",
&mut stack
));
skip_tree(&mut stack);
try!(end_element(&actual_tag_name, &mut stack));
}
Ok(result)
}))
})
}
fn modify_cluster_iam_roles(
&self,
input: ModifyClusterIamRolesMessage,
) -> RusotoFuture<ModifyClusterIamRolesResult, ModifyClusterIamRolesError> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let mut params = Params::new();
params.put("Action", "ModifyClusterIamRoles");
params.put("Version", "2012-12-01");
ModifyClusterIamRolesMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response.buffer().from_err().and_then(|response| {
Err(ModifyClusterIamRolesError::from_response(response))
}),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = ModifyClusterIamRolesResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = try!(peek_at_name(&mut stack));
try!(start_element(&actual_tag_name, &mut stack));
result = try!(ModifyClusterIamRolesResultDeserializer::deserialize(
"ModifyClusterIamRolesResult",
&mut stack
));
skip_tree(&mut stack);
try!(end_element(&actual_tag_name, &mut stack));
}
Ok(result)
}))
})
}
fn modify_cluster_parameter_group(
&self,
input: ModifyClusterParameterGroupMessage,
) -> RusotoFuture<ClusterParameterGroupNameMessage, ModifyClusterParameterGroupError> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let mut params = Params::new();
params.put("Action", "ModifyClusterParameterGroup");
params.put("Version", "2012-12-01");
ModifyClusterParameterGroupMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(ModifyClusterParameterGroupError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = ClusterParameterGroupNameMessage::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = try!(peek_at_name(&mut stack));
try!(start_element(&actual_tag_name, &mut stack));
result = try!(ClusterParameterGroupNameMessageDeserializer::deserialize(
"ModifyClusterParameterGroupResult",
&mut stack
));
skip_tree(&mut stack);
try!(end_element(&actual_tag_name, &mut stack));
}
Ok(result)
}))
})
}
fn modify_cluster_subnet_group(
&self,
input: ModifyClusterSubnetGroupMessage,
) -> RusotoFuture<ModifyClusterSubnetGroupResult, ModifyClusterSubnetGroupError> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let mut params = Params::new();
params.put("Action", "ModifyClusterSubnetGroup");
params.put("Version", "2012-12-01");
ModifyClusterSubnetGroupMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(ModifyClusterSubnetGroupError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = ModifyClusterSubnetGroupResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = try!(peek_at_name(&mut stack));
try!(start_element(&actual_tag_name, &mut stack));
result = try!(ModifyClusterSubnetGroupResultDeserializer::deserialize(
"ModifyClusterSubnetGroupResult",
&mut stack
));
skip_tree(&mut stack);
try!(end_element(&actual_tag_name, &mut stack));
}
Ok(result)
}))
})
}
fn modify_event_subscription(
&self,
input: ModifyEventSubscriptionMessage,
) -> RusotoFuture<ModifyEventSubscriptionResult, ModifyEventSubscriptionError> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let mut params = Params::new();
params.put("Action", "ModifyEventSubscription");
params.put("Version", "2012-12-01");
ModifyEventSubscriptionMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(ModifyEventSubscriptionError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = ModifyEventSubscriptionResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = try!(peek_at_name(&mut stack));
try!(start_element(&actual_tag_name, &mut stack));
result = try!(ModifyEventSubscriptionResultDeserializer::deserialize(
"ModifyEventSubscriptionResult",
&mut stack
));
skip_tree(&mut stack);
try!(end_element(&actual_tag_name, &mut stack));
}
Ok(result)
}))
})
}
fn modify_snapshot_copy_retention_period(
&self,
input: ModifySnapshotCopyRetentionPeriodMessage,
) -> RusotoFuture<ModifySnapshotCopyRetentionPeriodResult, ModifySnapshotCopyRetentionPeriodError>
{
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let mut params = Params::new();
params.put("Action", "ModifySnapshotCopyRetentionPeriod");
params.put("Version", "2012-12-01");
ModifySnapshotCopyRetentionPeriodMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(ModifySnapshotCopyRetentionPeriodError::from_response(
response,
))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = ModifySnapshotCopyRetentionPeriodResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = try!(peek_at_name(&mut stack));
try!(start_element(&actual_tag_name, &mut stack));
result = try!(
ModifySnapshotCopyRetentionPeriodResultDeserializer::deserialize(
"ModifySnapshotCopyRetentionPeriodResult",
&mut stack
)
);
skip_tree(&mut stack);
try!(end_element(&actual_tag_name, &mut stack));
}
Ok(result)
}))
})
}
fn purchase_reserved_node_offering(
&self,
input: PurchaseReservedNodeOfferingMessage,
) -> RusotoFuture<PurchaseReservedNodeOfferingResult, PurchaseReservedNodeOfferingError> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let mut params = Params::new();
params.put("Action", "PurchaseReservedNodeOffering");
params.put("Version", "2012-12-01");
PurchaseReservedNodeOfferingMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(PurchaseReservedNodeOfferingError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = PurchaseReservedNodeOfferingResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = try!(peek_at_name(&mut stack));
try!(start_element(&actual_tag_name, &mut stack));
result = try!(PurchaseReservedNodeOfferingResultDeserializer::deserialize(
"PurchaseReservedNodeOfferingResult",
&mut stack
));
skip_tree(&mut stack);
try!(end_element(&actual_tag_name, &mut stack));
}
Ok(result)
}))
})
}
fn reboot_cluster(
&self,
input: RebootClusterMessage,
) -> RusotoFuture<RebootClusterResult, RebootClusterError> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let mut params = Params::new();
params.put("Action", "RebootCluster");
params.put("Version", "2012-12-01");
RebootClusterMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(RebootClusterError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = RebootClusterResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = try!(peek_at_name(&mut stack));
try!(start_element(&actual_tag_name, &mut stack));
result = try!(RebootClusterResultDeserializer::deserialize(
"RebootClusterResult",
&mut stack
));
skip_tree(&mut stack);
try!(end_element(&actual_tag_name, &mut stack));
}
Ok(result)
}))
})
}
fn reset_cluster_parameter_group(
&self,
input: ResetClusterParameterGroupMessage,
) -> RusotoFuture<ClusterParameterGroupNameMessage, ResetClusterParameterGroupError> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let mut params = Params::new();
params.put("Action", "ResetClusterParameterGroup");
params.put("Version", "2012-12-01");
ResetClusterParameterGroupMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(ResetClusterParameterGroupError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = ClusterParameterGroupNameMessage::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = try!(peek_at_name(&mut stack));
try!(start_element(&actual_tag_name, &mut stack));
result = try!(ClusterParameterGroupNameMessageDeserializer::deserialize(
"ResetClusterParameterGroupResult",
&mut stack
));
skip_tree(&mut stack);
try!(end_element(&actual_tag_name, &mut stack));
}
Ok(result)
}))
})
}
fn restore_from_cluster_snapshot(
&self,
input: RestoreFromClusterSnapshotMessage,
) -> RusotoFuture<RestoreFromClusterSnapshotResult, RestoreFromClusterSnapshotError> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let mut params = Params::new();
params.put("Action", "RestoreFromClusterSnapshot");
params.put("Version", "2012-12-01");
RestoreFromClusterSnapshotMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(RestoreFromClusterSnapshotError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = RestoreFromClusterSnapshotResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = try!(peek_at_name(&mut stack));
try!(start_element(&actual_tag_name, &mut stack));
result = try!(RestoreFromClusterSnapshotResultDeserializer::deserialize(
"RestoreFromClusterSnapshotResult",
&mut stack
));
skip_tree(&mut stack);
try!(end_element(&actual_tag_name, &mut stack));
}
Ok(result)
}))
})
}
fn restore_table_from_cluster_snapshot(
&self,
input: RestoreTableFromClusterSnapshotMessage,
) -> RusotoFuture<RestoreTableFromClusterSnapshotResult, RestoreTableFromClusterSnapshotError>
{
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let mut params = Params::new();
params.put("Action", "RestoreTableFromClusterSnapshot");
params.put("Version", "2012-12-01");
RestoreTableFromClusterSnapshotMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(RestoreTableFromClusterSnapshotError::from_response(
response,
))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = RestoreTableFromClusterSnapshotResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = try!(peek_at_name(&mut stack));
try!(start_element(&actual_tag_name, &mut stack));
result = try!(
RestoreTableFromClusterSnapshotResultDeserializer::deserialize(
"RestoreTableFromClusterSnapshotResult",
&mut stack
)
);
skip_tree(&mut stack);
try!(end_element(&actual_tag_name, &mut stack));
}
Ok(result)
}))
})
}
fn revoke_cluster_security_group_ingress(
&self,
input: RevokeClusterSecurityGroupIngressMessage,
) -> RusotoFuture<RevokeClusterSecurityGroupIngressResult, RevokeClusterSecurityGroupIngressError>
{
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let mut params = Params::new();
params.put("Action", "RevokeClusterSecurityGroupIngress");
params.put("Version", "2012-12-01");
RevokeClusterSecurityGroupIngressMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(RevokeClusterSecurityGroupIngressError::from_response(
response,
))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = RevokeClusterSecurityGroupIngressResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = try!(peek_at_name(&mut stack));
try!(start_element(&actual_tag_name, &mut stack));
result = try!(
RevokeClusterSecurityGroupIngressResultDeserializer::deserialize(
"RevokeClusterSecurityGroupIngressResult",
&mut stack
)
);
skip_tree(&mut stack);
try!(end_element(&actual_tag_name, &mut stack));
}
Ok(result)
}))
})
}
fn revoke_snapshot_access(
&self,
input: RevokeSnapshotAccessMessage,
) -> RusotoFuture<RevokeSnapshotAccessResult, RevokeSnapshotAccessError> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let mut params = Params::new();
params.put("Action", "RevokeSnapshotAccess");
params.put("Version", "2012-12-01");
RevokeSnapshotAccessMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response.buffer().from_err().and_then(|response| {
Err(RevokeSnapshotAccessError::from_response(response))
}),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = RevokeSnapshotAccessResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = try!(peek_at_name(&mut stack));
try!(start_element(&actual_tag_name, &mut stack));
result = try!(RevokeSnapshotAccessResultDeserializer::deserialize(
"RevokeSnapshotAccessResult",
&mut stack
));
skip_tree(&mut stack);
try!(end_element(&actual_tag_name, &mut stack));
}
Ok(result)
}))
})
}
fn rotate_encryption_key(
&self,
input: RotateEncryptionKeyMessage,
) -> RusotoFuture<RotateEncryptionKeyResult, RotateEncryptionKeyError> {
let mut request = SignedRequest::new("POST", "redshift", &self.region, "/");
let mut params = Params::new();
params.put("Action", "RotateEncryptionKey");
params.put("Version", "2012-12-01");
RotateEncryptionKeyMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(
serde_urlencoded::to_string(¶ms).unwrap().into_bytes(),
));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response.buffer().from_err().and_then(|response| {
Err(RotateEncryptionKeyError::from_response(response))
}),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = RotateEncryptionKeyResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = try!(peek_at_name(&mut stack));
try!(start_element(&actual_tag_name, &mut stack));
result = try!(RotateEncryptionKeyResultDeserializer::deserialize(
"RotateEncryptionKeyResult",
&mut stack
));
skip_tree(&mut stack);
try!(end_element(&actual_tag_name, &mut stack));
}
Ok(result)
}))
})
}
}
#[cfg(test)]
mod protocol_tests {
extern crate rusoto_mock;
use self::rusoto_mock::*;
use super::*;
use rusoto_core::Region as rusoto_region;
#[test]
fn test_parse_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)
.sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
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).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
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).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
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).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
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).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
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).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
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).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
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).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
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).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
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).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
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).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
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).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
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).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
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).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
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).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
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).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
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).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
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).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
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).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
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).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
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).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
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).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
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).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
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).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
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).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
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).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
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).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
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).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
}