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 AddRoleToDBClusterMessage {
pub db_cluster_identifier: String,
pub role_arn: String,
}
struct AddRoleToDBClusterMessageSerializer;
impl AddRoleToDBClusterMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &AddRoleToDBClusterMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "DBClusterIdentifier"),
&obj.db_cluster_identifier,
);
params.put(&format!("{}{}", prefix, "RoleArn"), &obj.role_arn);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct AddSourceIdentifierToSubscriptionMessage {
pub source_identifier: String,
pub subscription_name: String,
}
struct AddSourceIdentifierToSubscriptionMessageSerializer;
impl AddSourceIdentifierToSubscriptionMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &AddSourceIdentifierToSubscriptionMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "SourceIdentifier"),
&obj.source_identifier,
);
params.put(
&format!("{}{}", prefix, "SubscriptionName"),
&obj.subscription_name,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct AddSourceIdentifierToSubscriptionResult {
pub event_subscription: Option<EventSubscription>,
}
struct AddSourceIdentifierToSubscriptionResultDeserializer;
impl AddSourceIdentifierToSubscriptionResultDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<AddSourceIdentifierToSubscriptionResult, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = AddSourceIdentifierToSubscriptionResult::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(EventSubscriptionDeserializer::deserialize(
"EventSubscription",
stack,
)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct AddTagsToResourceMessage {
pub resource_name: String,
pub tags: Vec<Tag>,
}
struct AddTagsToResourceMessageSerializer;
impl AddTagsToResourceMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &AddTagsToResourceMessage) {
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 ApplyMethodDeserializer;
impl ApplyMethodDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ApplyPendingMaintenanceActionMessage {
pub apply_action: String,
pub opt_in_type: String,
pub resource_identifier: String,
}
struct ApplyPendingMaintenanceActionMessageSerializer;
impl ApplyPendingMaintenanceActionMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ApplyPendingMaintenanceActionMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(&format!("{}{}", prefix, "ApplyAction"), &obj.apply_action);
params.put(&format!("{}{}", prefix, "OptInType"), &obj.opt_in_type);
params.put(
&format!("{}{}", prefix, "ResourceIdentifier"),
&obj.resource_identifier,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ApplyPendingMaintenanceActionResult {
pub resource_pending_maintenance_actions: Option<ResourcePendingMaintenanceActions>,
}
struct ApplyPendingMaintenanceActionResultDeserializer;
impl ApplyPendingMaintenanceActionResultDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ApplyPendingMaintenanceActionResult, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = ApplyPendingMaintenanceActionResult::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[..] {
"ResourcePendingMaintenanceActions" => {
obj.resource_pending_maintenance_actions =
Some(ResourcePendingMaintenanceActionsDeserializer::deserialize(
"ResourcePendingMaintenanceActions",
stack,
)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct AttributeValueListDeserializer;
impl AttributeValueListDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<String>, XmlParseError> {
let mut obj = vec![];
start_element(tag_name, stack)?;
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "AttributeValue" {
obj.push(StringDeserializer::deserialize("AttributeValue", stack)?);
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
end_element(tag_name, stack)?;
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
struct AttributeValueListSerializer;
impl AttributeValueListSerializer {
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 AvailabilityZone {
pub name: Option<String>,
}
struct AvailabilityZoneDeserializer;
impl AvailabilityZoneDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<AvailabilityZone, XmlParseError> {
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(StringDeserializer::deserialize("Name", stack)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
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![];
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(AvailabilityZoneDeserializer::deserialize(
"AvailabilityZone",
stack,
)?);
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
end_element(tag_name, stack)?;
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
struct AvailabilityZonesDeserializer;
impl AvailabilityZonesDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<String>, XmlParseError> {
let mut obj = vec![];
start_element(tag_name, stack)?;
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "AvailabilityZone" {
obj.push(StringDeserializer::deserialize("AvailabilityZone", stack)?);
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
end_element(tag_name, stack)?;
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
struct AvailabilityZonesSerializer;
impl AvailabilityZonesSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.member.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
struct BooleanDeserializer;
impl BooleanDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<bool, XmlParseError> {
start_element(tag_name, stack)?;
let obj = bool::from_str(characters(stack)?.as_ref()).unwrap();
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct BooleanOptionalDeserializer;
impl BooleanOptionalDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<bool, XmlParseError> {
start_element(tag_name, stack)?;
let obj = bool::from_str(characters(stack)?.as_ref()).unwrap();
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CharacterSet {
pub character_set_description: Option<String>,
pub character_set_name: Option<String>,
}
struct CharacterSetDeserializer;
impl CharacterSetDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CharacterSet, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = CharacterSet::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[..] {
"CharacterSetDescription" => {
obj.character_set_description = Some(StringDeserializer::deserialize(
"CharacterSetDescription",
stack,
)?);
}
"CharacterSetName" => {
obj.character_set_name =
Some(StringDeserializer::deserialize("CharacterSetName", stack)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CloudwatchLogsExportConfiguration {
pub disable_log_types: Option<Vec<String>>,
pub enable_log_types: Option<Vec<String>>,
}
struct CloudwatchLogsExportConfigurationSerializer;
impl CloudwatchLogsExportConfigurationSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CloudwatchLogsExportConfiguration) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.disable_log_types {
LogTypeListSerializer::serialize(
params,
&format!("{}{}", prefix, "DisableLogTypes"),
field_value,
);
}
if let Some(ref field_value) = obj.enable_log_types {
LogTypeListSerializer::serialize(
params,
&format!("{}{}", prefix, "EnableLogTypes"),
field_value,
);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CopyDBClusterParameterGroupMessage {
pub source_db_cluster_parameter_group_identifier: String,
pub tags: Option<Vec<Tag>>,
pub target_db_cluster_parameter_group_description: String,
pub target_db_cluster_parameter_group_identifier: String,
}
struct CopyDBClusterParameterGroupMessageSerializer;
impl CopyDBClusterParameterGroupMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CopyDBClusterParameterGroupMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "SourceDBClusterParameterGroupIdentifier"),
&obj.source_db_cluster_parameter_group_identifier,
);
if let Some(ref field_value) = obj.tags {
TagListSerializer::serialize(params, &format!("{}{}", prefix, "Tag"), field_value);
}
params.put(
&format!("{}{}", prefix, "TargetDBClusterParameterGroupDescription"),
&obj.target_db_cluster_parameter_group_description,
);
params.put(
&format!("{}{}", prefix, "TargetDBClusterParameterGroupIdentifier"),
&obj.target_db_cluster_parameter_group_identifier,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CopyDBClusterParameterGroupResult {
pub db_cluster_parameter_group: Option<DBClusterParameterGroup>,
}
struct CopyDBClusterParameterGroupResultDeserializer;
impl CopyDBClusterParameterGroupResultDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CopyDBClusterParameterGroupResult, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = CopyDBClusterParameterGroupResult::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[..] {
"DBClusterParameterGroup" => {
obj.db_cluster_parameter_group =
Some(DBClusterParameterGroupDeserializer::deserialize(
"DBClusterParameterGroup",
stack,
)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CopyDBClusterSnapshotMessage {
pub copy_tags: Option<bool>,
pub kms_key_id: Option<String>,
pub pre_signed_url: Option<String>,
pub source_db_cluster_snapshot_identifier: String,
pub tags: Option<Vec<Tag>>,
pub target_db_cluster_snapshot_identifier: String,
}
struct CopyDBClusterSnapshotMessageSerializer;
impl CopyDBClusterSnapshotMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CopyDBClusterSnapshotMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.copy_tags {
params.put(
&format!("{}{}", prefix, "CopyTags"),
&field_value.to_string(),
);
}
if let Some(ref field_value) = obj.kms_key_id {
params.put(&format!("{}{}", prefix, "KmsKeyId"), &field_value);
}
if let Some(ref field_value) = obj.pre_signed_url {
params.put(&format!("{}{}", prefix, "PreSignedUrl"), &field_value);
}
params.put(
&format!("{}{}", prefix, "SourceDBClusterSnapshotIdentifier"),
&obj.source_db_cluster_snapshot_identifier,
);
if let Some(ref field_value) = obj.tags {
TagListSerializer::serialize(params, &format!("{}{}", prefix, "Tag"), field_value);
}
params.put(
&format!("{}{}", prefix, "TargetDBClusterSnapshotIdentifier"),
&obj.target_db_cluster_snapshot_identifier,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CopyDBClusterSnapshotResult {
pub db_cluster_snapshot: Option<DBClusterSnapshot>,
}
struct CopyDBClusterSnapshotResultDeserializer;
impl CopyDBClusterSnapshotResultDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CopyDBClusterSnapshotResult, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = CopyDBClusterSnapshotResult::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[..] {
"DBClusterSnapshot" => {
obj.db_cluster_snapshot = Some(DBClusterSnapshotDeserializer::deserialize(
"DBClusterSnapshot",
stack,
)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CopyDBParameterGroupMessage {
pub source_db_parameter_group_identifier: String,
pub tags: Option<Vec<Tag>>,
pub target_db_parameter_group_description: String,
pub target_db_parameter_group_identifier: String,
}
struct CopyDBParameterGroupMessageSerializer;
impl CopyDBParameterGroupMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CopyDBParameterGroupMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "SourceDBParameterGroupIdentifier"),
&obj.source_db_parameter_group_identifier,
);
if let Some(ref field_value) = obj.tags {
TagListSerializer::serialize(params, &format!("{}{}", prefix, "Tag"), field_value);
}
params.put(
&format!("{}{}", prefix, "TargetDBParameterGroupDescription"),
&obj.target_db_parameter_group_description,
);
params.put(
&format!("{}{}", prefix, "TargetDBParameterGroupIdentifier"),
&obj.target_db_parameter_group_identifier,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CopyDBParameterGroupResult {
pub db_parameter_group: Option<DBParameterGroup>,
}
struct CopyDBParameterGroupResultDeserializer;
impl CopyDBParameterGroupResultDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CopyDBParameterGroupResult, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = CopyDBParameterGroupResult::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[..] {
"DBParameterGroup" => {
obj.db_parameter_group = Some(DBParameterGroupDeserializer::deserialize(
"DBParameterGroup",
stack,
)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateDBClusterMessage {
pub availability_zones: Option<Vec<String>>,
pub backup_retention_period: Option<i64>,
pub character_set_name: Option<String>,
pub db_cluster_identifier: String,
pub db_cluster_parameter_group_name: Option<String>,
pub db_subnet_group_name: Option<String>,
pub database_name: Option<String>,
pub enable_iam_database_authentication: Option<bool>,
pub engine: String,
pub engine_version: Option<String>,
pub kms_key_id: Option<String>,
pub master_user_password: Option<String>,
pub master_username: Option<String>,
pub option_group_name: Option<String>,
pub port: Option<i64>,
pub pre_signed_url: Option<String>,
pub preferred_backup_window: Option<String>,
pub preferred_maintenance_window: Option<String>,
pub replication_source_identifier: Option<String>,
pub storage_encrypted: Option<bool>,
pub tags: Option<Vec<Tag>>,
pub vpc_security_group_ids: Option<Vec<String>>,
}
struct CreateDBClusterMessageSerializer;
impl CreateDBClusterMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CreateDBClusterMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.availability_zones {
AvailabilityZonesSerializer::serialize(
params,
&format!("{}{}", prefix, "AvailabilityZone"),
field_value,
);
}
if let Some(ref field_value) = obj.backup_retention_period {
params.put(
&format!("{}{}", prefix, "BackupRetentionPeriod"),
&field_value.to_string(),
);
}
if let Some(ref field_value) = obj.character_set_name {
params.put(&format!("{}{}", prefix, "CharacterSetName"), &field_value);
}
params.put(
&format!("{}{}", prefix, "DBClusterIdentifier"),
&obj.db_cluster_identifier,
);
if let Some(ref field_value) = obj.db_cluster_parameter_group_name {
params.put(
&format!("{}{}", prefix, "DBClusterParameterGroupName"),
&field_value,
);
}
if let Some(ref field_value) = obj.db_subnet_group_name {
params.put(&format!("{}{}", prefix, "DBSubnetGroupName"), &field_value);
}
if let Some(ref field_value) = obj.database_name {
params.put(&format!("{}{}", prefix, "DatabaseName"), &field_value);
}
if let Some(ref field_value) = obj.enable_iam_database_authentication {
params.put(
&format!("{}{}", prefix, "EnableIAMDatabaseAuthentication"),
&field_value.to_string(),
);
}
params.put(&format!("{}{}", prefix, "Engine"), &obj.engine);
if let Some(ref field_value) = obj.engine_version {
params.put(&format!("{}{}", prefix, "EngineVersion"), &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.master_user_password {
params.put(&format!("{}{}", prefix, "MasterUserPassword"), &field_value);
}
if let Some(ref field_value) = obj.master_username {
params.put(&format!("{}{}", prefix, "MasterUsername"), &field_value);
}
if let Some(ref field_value) = obj.option_group_name {
params.put(&format!("{}{}", prefix, "OptionGroupName"), &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.pre_signed_url {
params.put(&format!("{}{}", prefix, "PreSignedUrl"), &field_value);
}
if let Some(ref field_value) = obj.preferred_backup_window {
params.put(
&format!("{}{}", prefix, "PreferredBackupWindow"),
&field_value,
);
}
if let Some(ref field_value) = obj.preferred_maintenance_window {
params.put(
&format!("{}{}", prefix, "PreferredMaintenanceWindow"),
&field_value,
);
}
if let Some(ref field_value) = obj.replication_source_identifier {
params.put(
&format!("{}{}", prefix, "ReplicationSourceIdentifier"),
&field_value,
);
}
if let Some(ref field_value) = obj.storage_encrypted {
params.put(
&format!("{}{}", prefix, "StorageEncrypted"),
&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 CreateDBClusterParameterGroupMessage {
pub db_cluster_parameter_group_name: String,
pub db_parameter_group_family: String,
pub description: String,
pub tags: Option<Vec<Tag>>,
}
struct CreateDBClusterParameterGroupMessageSerializer;
impl CreateDBClusterParameterGroupMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CreateDBClusterParameterGroupMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "DBClusterParameterGroupName"),
&obj.db_cluster_parameter_group_name,
);
params.put(
&format!("{}{}", prefix, "DBParameterGroupFamily"),
&obj.db_parameter_group_family,
);
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 CreateDBClusterParameterGroupResult {
pub db_cluster_parameter_group: Option<DBClusterParameterGroup>,
}
struct CreateDBClusterParameterGroupResultDeserializer;
impl CreateDBClusterParameterGroupResultDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CreateDBClusterParameterGroupResult, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = CreateDBClusterParameterGroupResult::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[..] {
"DBClusterParameterGroup" => {
obj.db_cluster_parameter_group =
Some(DBClusterParameterGroupDeserializer::deserialize(
"DBClusterParameterGroup",
stack,
)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateDBClusterResult {
pub db_cluster: Option<DBCluster>,
}
struct CreateDBClusterResultDeserializer;
impl CreateDBClusterResultDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CreateDBClusterResult, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = CreateDBClusterResult::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[..] {
"DBCluster" => {
obj.db_cluster =
Some(DBClusterDeserializer::deserialize("DBCluster", stack)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateDBClusterSnapshotMessage {
pub db_cluster_identifier: String,
pub db_cluster_snapshot_identifier: String,
pub tags: Option<Vec<Tag>>,
}
struct CreateDBClusterSnapshotMessageSerializer;
impl CreateDBClusterSnapshotMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CreateDBClusterSnapshotMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "DBClusterIdentifier"),
&obj.db_cluster_identifier,
);
params.put(
&format!("{}{}", prefix, "DBClusterSnapshotIdentifier"),
&obj.db_cluster_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 CreateDBClusterSnapshotResult {
pub db_cluster_snapshot: Option<DBClusterSnapshot>,
}
struct CreateDBClusterSnapshotResultDeserializer;
impl CreateDBClusterSnapshotResultDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CreateDBClusterSnapshotResult, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = CreateDBClusterSnapshotResult::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[..] {
"DBClusterSnapshot" => {
obj.db_cluster_snapshot = Some(DBClusterSnapshotDeserializer::deserialize(
"DBClusterSnapshot",
stack,
)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateDBInstanceMessage {
pub allocated_storage: Option<i64>,
pub auto_minor_version_upgrade: Option<bool>,
pub availability_zone: Option<String>,
pub backup_retention_period: Option<i64>,
pub character_set_name: Option<String>,
pub copy_tags_to_snapshot: Option<bool>,
pub db_cluster_identifier: Option<String>,
pub db_instance_class: String,
pub db_instance_identifier: String,
pub db_name: Option<String>,
pub db_parameter_group_name: Option<String>,
pub db_security_groups: Option<Vec<String>>,
pub db_subnet_group_name: Option<String>,
pub domain: Option<String>,
pub domain_iam_role_name: Option<String>,
pub enable_cloudwatch_logs_exports: Option<Vec<String>>,
pub enable_iam_database_authentication: Option<bool>,
pub enable_performance_insights: Option<bool>,
pub engine: String,
pub engine_version: Option<String>,
pub iops: Option<i64>,
pub kms_key_id: Option<String>,
pub license_model: Option<String>,
pub master_user_password: Option<String>,
pub master_username: Option<String>,
pub monitoring_interval: Option<i64>,
pub monitoring_role_arn: Option<String>,
pub multi_az: Option<bool>,
pub option_group_name: Option<String>,
pub performance_insights_kms_key_id: Option<String>,
pub port: Option<i64>,
pub preferred_backup_window: Option<String>,
pub preferred_maintenance_window: Option<String>,
pub promotion_tier: Option<i64>,
pub storage_encrypted: Option<bool>,
pub storage_type: Option<String>,
pub tags: Option<Vec<Tag>>,
pub tde_credential_arn: Option<String>,
pub tde_credential_password: Option<String>,
pub timezone: Option<String>,
pub vpc_security_group_ids: Option<Vec<String>>,
}
struct CreateDBInstanceMessageSerializer;
impl CreateDBInstanceMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CreateDBInstanceMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.allocated_storage {
params.put(
&format!("{}{}", prefix, "AllocatedStorage"),
&field_value.to_string(),
);
}
if let Some(ref field_value) = obj.auto_minor_version_upgrade {
params.put(
&format!("{}{}", prefix, "AutoMinorVersionUpgrade"),
&field_value.to_string(),
);
}
if let Some(ref field_value) = obj.availability_zone {
params.put(&format!("{}{}", prefix, "AvailabilityZone"), &field_value);
}
if let Some(ref field_value) = obj.backup_retention_period {
params.put(
&format!("{}{}", prefix, "BackupRetentionPeriod"),
&field_value.to_string(),
);
}
if let Some(ref field_value) = obj.character_set_name {
params.put(&format!("{}{}", prefix, "CharacterSetName"), &field_value);
}
if let Some(ref field_value) = obj.copy_tags_to_snapshot {
params.put(
&format!("{}{}", prefix, "CopyTagsToSnapshot"),
&field_value.to_string(),
);
}
if let Some(ref field_value) = obj.db_cluster_identifier {
params.put(
&format!("{}{}", prefix, "DBClusterIdentifier"),
&field_value,
);
}
params.put(
&format!("{}{}", prefix, "DBInstanceClass"),
&obj.db_instance_class,
);
params.put(
&format!("{}{}", prefix, "DBInstanceIdentifier"),
&obj.db_instance_identifier,
);
if let Some(ref field_value) = obj.db_name {
params.put(&format!("{}{}", prefix, "DBName"), &field_value);
}
if let Some(ref field_value) = obj.db_parameter_group_name {
params.put(
&format!("{}{}", prefix, "DBParameterGroupName"),
&field_value,
);
}
if let Some(ref field_value) = obj.db_security_groups {
DBSecurityGroupNameListSerializer::serialize(
params,
&format!("{}{}", prefix, "DBSecurityGroupName"),
field_value,
);
}
if let Some(ref field_value) = obj.db_subnet_group_name {
params.put(&format!("{}{}", prefix, "DBSubnetGroupName"), &field_value);
}
if let Some(ref field_value) = obj.domain {
params.put(&format!("{}{}", prefix, "Domain"), &field_value);
}
if let Some(ref field_value) = obj.domain_iam_role_name {
params.put(&format!("{}{}", prefix, "DomainIAMRoleName"), &field_value);
}
if let Some(ref field_value) = obj.enable_cloudwatch_logs_exports {
LogTypeListSerializer::serialize(
params,
&format!("{}{}", prefix, "EnableCloudwatchLogsExports"),
field_value,
);
}
if let Some(ref field_value) = obj.enable_iam_database_authentication {
params.put(
&format!("{}{}", prefix, "EnableIAMDatabaseAuthentication"),
&field_value.to_string(),
);
}
if let Some(ref field_value) = obj.enable_performance_insights {
params.put(
&format!("{}{}", prefix, "EnablePerformanceInsights"),
&field_value.to_string(),
);
}
params.put(&format!("{}{}", prefix, "Engine"), &obj.engine);
if let Some(ref field_value) = obj.engine_version {
params.put(&format!("{}{}", prefix, "EngineVersion"), &field_value);
}
if let Some(ref field_value) = obj.iops {
params.put(&format!("{}{}", prefix, "Iops"), &field_value.to_string());
}
if let Some(ref field_value) = obj.kms_key_id {
params.put(&format!("{}{}", prefix, "KmsKeyId"), &field_value);
}
if let Some(ref field_value) = obj.license_model {
params.put(&format!("{}{}", prefix, "LicenseModel"), &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.master_username {
params.put(&format!("{}{}", prefix, "MasterUsername"), &field_value);
}
if let Some(ref field_value) = obj.monitoring_interval {
params.put(
&format!("{}{}", prefix, "MonitoringInterval"),
&field_value.to_string(),
);
}
if let Some(ref field_value) = obj.monitoring_role_arn {
params.put(&format!("{}{}", prefix, "MonitoringRoleArn"), &field_value);
}
if let Some(ref field_value) = obj.multi_az {
params.put(
&format!("{}{}", prefix, "MultiAZ"),
&field_value.to_string(),
);
}
if let Some(ref field_value) = obj.option_group_name {
params.put(&format!("{}{}", prefix, "OptionGroupName"), &field_value);
}
if let Some(ref field_value) = obj.performance_insights_kms_key_id {
params.put(
&format!("{}{}", prefix, "PerformanceInsightsKMSKeyId"),
&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_backup_window {
params.put(
&format!("{}{}", prefix, "PreferredBackupWindow"),
&field_value,
);
}
if let Some(ref field_value) = obj.preferred_maintenance_window {
params.put(
&format!("{}{}", prefix, "PreferredMaintenanceWindow"),
&field_value,
);
}
if let Some(ref field_value) = obj.promotion_tier {
params.put(
&format!("{}{}", prefix, "PromotionTier"),
&field_value.to_string(),
);
}
if let Some(ref field_value) = obj.storage_encrypted {
params.put(
&format!("{}{}", prefix, "StorageEncrypted"),
&field_value.to_string(),
);
}
if let Some(ref field_value) = obj.storage_type {
params.put(&format!("{}{}", prefix, "StorageType"), &field_value);
}
if let Some(ref field_value) = obj.tags {
TagListSerializer::serialize(params, &format!("{}{}", prefix, "Tag"), field_value);
}
if let Some(ref field_value) = obj.tde_credential_arn {
params.put(&format!("{}{}", prefix, "TdeCredentialArn"), &field_value);
}
if let Some(ref field_value) = obj.tde_credential_password {
params.put(
&format!("{}{}", prefix, "TdeCredentialPassword"),
&field_value,
);
}
if let Some(ref field_value) = obj.timezone {
params.put(&format!("{}{}", prefix, "Timezone"), &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 CreateDBInstanceResult {
pub db_instance: Option<DBInstance>,
}
struct CreateDBInstanceResultDeserializer;
impl CreateDBInstanceResultDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CreateDBInstanceResult, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = CreateDBInstanceResult::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[..] {
"DBInstance" => {
obj.db_instance =
Some(DBInstanceDeserializer::deserialize("DBInstance", stack)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateDBParameterGroupMessage {
pub db_parameter_group_family: String,
pub db_parameter_group_name: String,
pub description: String,
pub tags: Option<Vec<Tag>>,
}
struct CreateDBParameterGroupMessageSerializer;
impl CreateDBParameterGroupMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CreateDBParameterGroupMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "DBParameterGroupFamily"),
&obj.db_parameter_group_family,
);
params.put(
&format!("{}{}", prefix, "DBParameterGroupName"),
&obj.db_parameter_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 CreateDBParameterGroupResult {
pub db_parameter_group: Option<DBParameterGroup>,
}
struct CreateDBParameterGroupResultDeserializer;
impl CreateDBParameterGroupResultDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CreateDBParameterGroupResult, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = CreateDBParameterGroupResult::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[..] {
"DBParameterGroup" => {
obj.db_parameter_group = Some(DBParameterGroupDeserializer::deserialize(
"DBParameterGroup",
stack,
)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateDBSubnetGroupMessage {
pub db_subnet_group_description: String,
pub db_subnet_group_name: String,
pub subnet_ids: Vec<String>,
pub tags: Option<Vec<Tag>>,
}
struct CreateDBSubnetGroupMessageSerializer;
impl CreateDBSubnetGroupMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CreateDBSubnetGroupMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "DBSubnetGroupDescription"),
&obj.db_subnet_group_description,
);
params.put(
&format!("{}{}", prefix, "DBSubnetGroupName"),
&obj.db_subnet_group_name,
);
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 CreateDBSubnetGroupResult {
pub db_subnet_group: Option<DBSubnetGroup>,
}
struct CreateDBSubnetGroupResultDeserializer;
impl CreateDBSubnetGroupResultDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CreateDBSubnetGroupResult, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = CreateDBSubnetGroupResult::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[..] {
"DBSubnetGroup" => {
obj.db_subnet_group = Some(DBSubnetGroupDeserializer::deserialize(
"DBSubnetGroup",
stack,
)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateEventSubscriptionMessage {
pub enabled: Option<bool>,
pub event_categories: Option<Vec<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,
);
}
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> {
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(EventSubscriptionDeserializer::deserialize(
"EventSubscription",
stack,
)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DBCluster {
pub allocated_storage: Option<i64>,
pub associated_roles: Option<Vec<DBClusterRole>>,
pub availability_zones: Option<Vec<String>>,
pub backup_retention_period: Option<i64>,
pub character_set_name: Option<String>,
pub clone_group_id: Option<String>,
pub cluster_create_time: Option<String>,
pub db_cluster_arn: Option<String>,
pub db_cluster_identifier: Option<String>,
pub db_cluster_members: Option<Vec<DBClusterMember>>,
pub db_cluster_option_group_memberships: Option<Vec<DBClusterOptionGroupStatus>>,
pub db_cluster_parameter_group: Option<String>,
pub db_subnet_group: Option<String>,
pub database_name: Option<String>,
pub db_cluster_resource_id: Option<String>,
pub earliest_restorable_time: Option<String>,
pub endpoint: Option<String>,
pub engine: Option<String>,
pub engine_version: Option<String>,
pub hosted_zone_id: Option<String>,
pub iam_database_authentication_enabled: Option<bool>,
pub kms_key_id: Option<String>,
pub latest_restorable_time: Option<String>,
pub master_username: Option<String>,
pub multi_az: Option<bool>,
pub percent_progress: Option<String>,
pub port: Option<i64>,
pub preferred_backup_window: Option<String>,
pub preferred_maintenance_window: Option<String>,
pub read_replica_identifiers: Option<Vec<String>>,
pub reader_endpoint: Option<String>,
pub replication_source_identifier: Option<String>,
pub status: Option<String>,
pub storage_encrypted: Option<bool>,
pub vpc_security_groups: Option<Vec<VpcSecurityGroupMembership>>,
}
struct DBClusterDeserializer;
impl DBClusterDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DBCluster, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = DBCluster::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[..] {
"AllocatedStorage" => {
obj.allocated_storage = Some(IntegerOptionalDeserializer::deserialize(
"AllocatedStorage",
stack,
)?);
}
"AssociatedRoles" => {
obj.associated_roles = match obj.associated_roles {
Some(ref mut existing) => {
existing.extend(DBClusterRolesDeserializer::deserialize(
"AssociatedRoles",
stack,
)?);
Some(existing.to_vec())
}
None => Some(DBClusterRolesDeserializer::deserialize(
"AssociatedRoles",
stack,
)?),
};
}
"AvailabilityZones" => {
obj.availability_zones = match obj.availability_zones {
Some(ref mut existing) => {
existing.extend(AvailabilityZonesDeserializer::deserialize(
"AvailabilityZones",
stack,
)?);
Some(existing.to_vec())
}
None => Some(AvailabilityZonesDeserializer::deserialize(
"AvailabilityZones",
stack,
)?),
};
}
"BackupRetentionPeriod" => {
obj.backup_retention_period =
Some(IntegerOptionalDeserializer::deserialize(
"BackupRetentionPeriod",
stack,
)?);
}
"CharacterSetName" => {
obj.character_set_name =
Some(StringDeserializer::deserialize("CharacterSetName", stack)?);
}
"CloneGroupId" => {
obj.clone_group_id =
Some(StringDeserializer::deserialize("CloneGroupId", stack)?);
}
"ClusterCreateTime" => {
obj.cluster_create_time =
Some(TStampDeserializer::deserialize("ClusterCreateTime", stack)?);
}
"DBClusterArn" => {
obj.db_cluster_arn =
Some(StringDeserializer::deserialize("DBClusterArn", stack)?);
}
"DBClusterIdentifier" => {
obj.db_cluster_identifier = Some(StringDeserializer::deserialize(
"DBClusterIdentifier",
stack,
)?);
}
"DBClusterMembers" => {
obj.db_cluster_members = match obj.db_cluster_members {
Some(ref mut existing) => {
existing.extend(DBClusterMemberListDeserializer::deserialize(
"DBClusterMembers",
stack,
)?);
Some(existing.to_vec())
}
None => Some(DBClusterMemberListDeserializer::deserialize(
"DBClusterMembers",
stack,
)?),
};
}
"DBClusterOptionGroupMemberships" => {
obj.db_cluster_option_group_memberships = match obj
.db_cluster_option_group_memberships
{
Some(ref mut existing) => {
existing.extend(
DBClusterOptionGroupMembershipsDeserializer::deserialize(
"DBClusterOptionGroupMemberships",
stack,
)?,
);
Some(existing.to_vec())
}
None => Some(DBClusterOptionGroupMembershipsDeserializer::deserialize(
"DBClusterOptionGroupMemberships",
stack,
)?),
};
}
"DBClusterParameterGroup" => {
obj.db_cluster_parameter_group = Some(StringDeserializer::deserialize(
"DBClusterParameterGroup",
stack,
)?);
}
"DBSubnetGroup" => {
obj.db_subnet_group =
Some(StringDeserializer::deserialize("DBSubnetGroup", stack)?);
}
"DatabaseName" => {
obj.database_name =
Some(StringDeserializer::deserialize("DatabaseName", stack)?);
}
"DbClusterResourceId" => {
obj.db_cluster_resource_id = Some(StringDeserializer::deserialize(
"DbClusterResourceId",
stack,
)?);
}
"EarliestRestorableTime" => {
obj.earliest_restorable_time = Some(TStampDeserializer::deserialize(
"EarliestRestorableTime",
stack,
)?);
}
"Endpoint" => {
obj.endpoint = Some(StringDeserializer::deserialize("Endpoint", stack)?);
}
"Engine" => {
obj.engine = Some(StringDeserializer::deserialize("Engine", stack)?);
}
"EngineVersion" => {
obj.engine_version =
Some(StringDeserializer::deserialize("EngineVersion", stack)?);
}
"HostedZoneId" => {
obj.hosted_zone_id =
Some(StringDeserializer::deserialize("HostedZoneId", stack)?);
}
"IAMDatabaseAuthenticationEnabled" => {
obj.iam_database_authentication_enabled =
Some(BooleanDeserializer::deserialize(
"IAMDatabaseAuthenticationEnabled",
stack,
)?);
}
"KmsKeyId" => {
obj.kms_key_id = Some(StringDeserializer::deserialize("KmsKeyId", stack)?);
}
"LatestRestorableTime" => {
obj.latest_restorable_time = Some(TStampDeserializer::deserialize(
"LatestRestorableTime",
stack,
)?);
}
"MasterUsername" => {
obj.master_username =
Some(StringDeserializer::deserialize("MasterUsername", stack)?);
}
"MultiAZ" => {
obj.multi_az = Some(BooleanDeserializer::deserialize("MultiAZ", stack)?);
}
"PercentProgress" => {
obj.percent_progress =
Some(StringDeserializer::deserialize("PercentProgress", stack)?);
}
"Port" => {
obj.port = Some(IntegerOptionalDeserializer::deserialize("Port", stack)?);
}
"PreferredBackupWindow" => {
obj.preferred_backup_window = Some(StringDeserializer::deserialize(
"PreferredBackupWindow",
stack,
)?);
}
"PreferredMaintenanceWindow" => {
obj.preferred_maintenance_window = Some(StringDeserializer::deserialize(
"PreferredMaintenanceWindow",
stack,
)?);
}
"ReadReplicaIdentifiers" => {
obj.read_replica_identifiers = match obj.read_replica_identifiers {
Some(ref mut existing) => {
existing.extend(
ReadReplicaIdentifierListDeserializer::deserialize(
"ReadReplicaIdentifiers",
stack,
)?,
);
Some(existing.to_vec())
}
None => Some(ReadReplicaIdentifierListDeserializer::deserialize(
"ReadReplicaIdentifiers",
stack,
)?),
};
}
"ReaderEndpoint" => {
obj.reader_endpoint =
Some(StringDeserializer::deserialize("ReaderEndpoint", stack)?);
}
"ReplicationSourceIdentifier" => {
obj.replication_source_identifier = Some(StringDeserializer::deserialize(
"ReplicationSourceIdentifier",
stack,
)?);
}
"Status" => {
obj.status = Some(StringDeserializer::deserialize("Status", stack)?);
}
"StorageEncrypted" => {
obj.storage_encrypted =
Some(BooleanDeserializer::deserialize("StorageEncrypted", stack)?);
}
"VpcSecurityGroups" => {
obj.vpc_security_groups = match obj.vpc_security_groups {
Some(ref mut existing) => {
existing.extend(
VpcSecurityGroupMembershipListDeserializer::deserialize(
"VpcSecurityGroups",
stack,
)?,
);
Some(existing.to_vec())
}
None => Some(VpcSecurityGroupMembershipListDeserializer::deserialize(
"VpcSecurityGroups",
stack,
)?),
};
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct DBClusterListDeserializer;
impl DBClusterListDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<DBCluster>, XmlParseError> {
let mut obj = vec![];
start_element(tag_name, stack)?;
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "DBCluster" {
obj.push(DBClusterDeserializer::deserialize("DBCluster", stack)?);
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
end_element(tag_name, stack)?;
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DBClusterMember {
pub db_cluster_parameter_group_status: Option<String>,
pub db_instance_identifier: Option<String>,
pub is_cluster_writer: Option<bool>,
pub promotion_tier: Option<i64>,
}
struct DBClusterMemberDeserializer;
impl DBClusterMemberDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DBClusterMember, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = DBClusterMember::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[..] {
"DBClusterParameterGroupStatus" => {
obj.db_cluster_parameter_group_status =
Some(StringDeserializer::deserialize(
"DBClusterParameterGroupStatus",
stack,
)?);
}
"DBInstanceIdentifier" => {
obj.db_instance_identifier = Some(StringDeserializer::deserialize(
"DBInstanceIdentifier",
stack,
)?);
}
"IsClusterWriter" => {
obj.is_cluster_writer =
Some(BooleanDeserializer::deserialize("IsClusterWriter", stack)?);
}
"PromotionTier" => {
obj.promotion_tier = Some(IntegerOptionalDeserializer::deserialize(
"PromotionTier",
stack,
)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct DBClusterMemberListDeserializer;
impl DBClusterMemberListDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<DBClusterMember>, XmlParseError> {
let mut obj = vec![];
start_element(tag_name, stack)?;
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "DBClusterMember" {
obj.push(DBClusterMemberDeserializer::deserialize(
"DBClusterMember",
stack,
)?);
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
end_element(tag_name, stack)?;
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DBClusterMessage {
pub db_clusters: Option<Vec<DBCluster>>,
pub marker: Option<String>,
}
struct DBClusterMessageDeserializer;
impl DBClusterMessageDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DBClusterMessage, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = DBClusterMessage::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[..] {
"DBClusters" => {
obj.db_clusters = match obj.db_clusters {
Some(ref mut existing) => {
existing.extend(DBClusterListDeserializer::deserialize(
"DBClusters",
stack,
)?);
Some(existing.to_vec())
}
None => {
Some(DBClusterListDeserializer::deserialize("DBClusters", stack)?)
}
};
}
"Marker" => {
obj.marker = Some(StringDeserializer::deserialize("Marker", stack)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct DBClusterOptionGroupMembershipsDeserializer;
impl DBClusterOptionGroupMembershipsDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<DBClusterOptionGroupStatus>, XmlParseError> {
let mut obj = vec![];
start_element(tag_name, stack)?;
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "DBClusterOptionGroup" {
obj.push(DBClusterOptionGroupStatusDeserializer::deserialize(
"DBClusterOptionGroup",
stack,
)?);
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
end_element(tag_name, stack)?;
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DBClusterOptionGroupStatus {
pub db_cluster_option_group_name: Option<String>,
pub status: Option<String>,
}
struct DBClusterOptionGroupStatusDeserializer;
impl DBClusterOptionGroupStatusDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DBClusterOptionGroupStatus, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = DBClusterOptionGroupStatus::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[..] {
"DBClusterOptionGroupName" => {
obj.db_cluster_option_group_name = Some(StringDeserializer::deserialize(
"DBClusterOptionGroupName",
stack,
)?);
}
"Status" => {
obj.status = Some(StringDeserializer::deserialize("Status", stack)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DBClusterParameterGroup {
pub db_cluster_parameter_group_arn: Option<String>,
pub db_cluster_parameter_group_name: Option<String>,
pub db_parameter_group_family: Option<String>,
pub description: Option<String>,
}
struct DBClusterParameterGroupDeserializer;
impl DBClusterParameterGroupDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DBClusterParameterGroup, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = DBClusterParameterGroup::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[..] {
"DBClusterParameterGroupArn" => {
obj.db_cluster_parameter_group_arn = Some(StringDeserializer::deserialize(
"DBClusterParameterGroupArn",
stack,
)?);
}
"DBClusterParameterGroupName" => {
obj.db_cluster_parameter_group_name = Some(
StringDeserializer::deserialize("DBClusterParameterGroupName", stack)?,
);
}
"DBParameterGroupFamily" => {
obj.db_parameter_group_family = Some(StringDeserializer::deserialize(
"DBParameterGroupFamily",
stack,
)?);
}
"Description" => {
obj.description =
Some(StringDeserializer::deserialize("Description", stack)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DBClusterParameterGroupDetails {
pub marker: Option<String>,
pub parameters: Option<Vec<Parameter>>,
}
struct DBClusterParameterGroupDetailsDeserializer;
impl DBClusterParameterGroupDetailsDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DBClusterParameterGroupDetails, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = DBClusterParameterGroupDetails::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(StringDeserializer::deserialize("Marker", stack)?);
}
"Parameters" => {
obj.parameters = match obj.parameters {
Some(ref mut existing) => {
existing.extend(ParametersListDeserializer::deserialize(
"Parameters",
stack,
)?);
Some(existing.to_vec())
}
None => Some(ParametersListDeserializer::deserialize(
"Parameters",
stack,
)?),
};
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct DBClusterParameterGroupListDeserializer;
impl DBClusterParameterGroupListDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<DBClusterParameterGroup>, XmlParseError> {
let mut obj = vec![];
start_element(tag_name, stack)?;
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "DBClusterParameterGroup" {
obj.push(DBClusterParameterGroupDeserializer::deserialize(
"DBClusterParameterGroup",
stack,
)?);
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
end_element(tag_name, stack)?;
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DBClusterParameterGroupNameMessage {
pub db_cluster_parameter_group_name: Option<String>,
}
struct DBClusterParameterGroupNameMessageDeserializer;
impl DBClusterParameterGroupNameMessageDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DBClusterParameterGroupNameMessage, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = DBClusterParameterGroupNameMessage::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[..] {
"DBClusterParameterGroupName" => {
obj.db_cluster_parameter_group_name = Some(
StringDeserializer::deserialize("DBClusterParameterGroupName", stack)?,
);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DBClusterParameterGroupsMessage {
pub db_cluster_parameter_groups: Option<Vec<DBClusterParameterGroup>>,
pub marker: Option<String>,
}
struct DBClusterParameterGroupsMessageDeserializer;
impl DBClusterParameterGroupsMessageDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DBClusterParameterGroupsMessage, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = DBClusterParameterGroupsMessage::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[..] {
"DBClusterParameterGroups" => {
obj.db_cluster_parameter_groups = match obj.db_cluster_parameter_groups {
Some(ref mut existing) => {
existing.extend(
DBClusterParameterGroupListDeserializer::deserialize(
"DBClusterParameterGroups",
stack,
)?,
);
Some(existing.to_vec())
}
None => Some(DBClusterParameterGroupListDeserializer::deserialize(
"DBClusterParameterGroups",
stack,
)?),
};
}
"Marker" => {
obj.marker = Some(StringDeserializer::deserialize("Marker", stack)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DBClusterRole {
pub role_arn: Option<String>,
pub status: Option<String>,
}
struct DBClusterRoleDeserializer;
impl DBClusterRoleDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DBClusterRole, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = DBClusterRole::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[..] {
"RoleArn" => {
obj.role_arn = Some(StringDeserializer::deserialize("RoleArn", stack)?);
}
"Status" => {
obj.status = Some(StringDeserializer::deserialize("Status", stack)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct DBClusterRolesDeserializer;
impl DBClusterRolesDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<DBClusterRole>, XmlParseError> {
let mut obj = vec![];
start_element(tag_name, stack)?;
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "DBClusterRole" {
obj.push(DBClusterRoleDeserializer::deserialize(
"DBClusterRole",
stack,
)?);
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
end_element(tag_name, stack)?;
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DBClusterSnapshot {
pub allocated_storage: Option<i64>,
pub availability_zones: Option<Vec<String>>,
pub cluster_create_time: Option<String>,
pub db_cluster_identifier: Option<String>,
pub db_cluster_snapshot_arn: Option<String>,
pub db_cluster_snapshot_identifier: Option<String>,
pub engine: Option<String>,
pub engine_version: Option<String>,
pub iam_database_authentication_enabled: Option<bool>,
pub kms_key_id: Option<String>,
pub license_model: Option<String>,
pub master_username: Option<String>,
pub percent_progress: Option<i64>,
pub port: Option<i64>,
pub snapshot_create_time: Option<String>,
pub snapshot_type: Option<String>,
pub source_db_cluster_snapshot_arn: Option<String>,
pub status: Option<String>,
pub storage_encrypted: Option<bool>,
pub vpc_id: Option<String>,
}
struct DBClusterSnapshotDeserializer;
impl DBClusterSnapshotDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DBClusterSnapshot, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = DBClusterSnapshot::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[..] {
"AllocatedStorage" => {
obj.allocated_storage =
Some(IntegerDeserializer::deserialize("AllocatedStorage", stack)?);
}
"AvailabilityZones" => {
obj.availability_zones = match obj.availability_zones {
Some(ref mut existing) => {
existing.extend(AvailabilityZonesDeserializer::deserialize(
"AvailabilityZones",
stack,
)?);
Some(existing.to_vec())
}
None => Some(AvailabilityZonesDeserializer::deserialize(
"AvailabilityZones",
stack,
)?),
};
}
"ClusterCreateTime" => {
obj.cluster_create_time =
Some(TStampDeserializer::deserialize("ClusterCreateTime", stack)?);
}
"DBClusterIdentifier" => {
obj.db_cluster_identifier = Some(StringDeserializer::deserialize(
"DBClusterIdentifier",
stack,
)?);
}
"DBClusterSnapshotArn" => {
obj.db_cluster_snapshot_arn = Some(StringDeserializer::deserialize(
"DBClusterSnapshotArn",
stack,
)?);
}
"DBClusterSnapshotIdentifier" => {
obj.db_cluster_snapshot_identifier = Some(StringDeserializer::deserialize(
"DBClusterSnapshotIdentifier",
stack,
)?);
}
"Engine" => {
obj.engine = Some(StringDeserializer::deserialize("Engine", stack)?);
}
"EngineVersion" => {
obj.engine_version =
Some(StringDeserializer::deserialize("EngineVersion", stack)?);
}
"IAMDatabaseAuthenticationEnabled" => {
obj.iam_database_authentication_enabled =
Some(BooleanDeserializer::deserialize(
"IAMDatabaseAuthenticationEnabled",
stack,
)?);
}
"KmsKeyId" => {
obj.kms_key_id = Some(StringDeserializer::deserialize("KmsKeyId", stack)?);
}
"LicenseModel" => {
obj.license_model =
Some(StringDeserializer::deserialize("LicenseModel", stack)?);
}
"MasterUsername" => {
obj.master_username =
Some(StringDeserializer::deserialize("MasterUsername", stack)?);
}
"PercentProgress" => {
obj.percent_progress =
Some(IntegerDeserializer::deserialize("PercentProgress", stack)?);
}
"Port" => {
obj.port = Some(IntegerDeserializer::deserialize("Port", stack)?);
}
"SnapshotCreateTime" => {
obj.snapshot_create_time = Some(TStampDeserializer::deserialize(
"SnapshotCreateTime",
stack,
)?);
}
"SnapshotType" => {
obj.snapshot_type =
Some(StringDeserializer::deserialize("SnapshotType", stack)?);
}
"SourceDBClusterSnapshotArn" => {
obj.source_db_cluster_snapshot_arn = Some(StringDeserializer::deserialize(
"SourceDBClusterSnapshotArn",
stack,
)?);
}
"Status" => {
obj.status = Some(StringDeserializer::deserialize("Status", stack)?);
}
"StorageEncrypted" => {
obj.storage_encrypted =
Some(BooleanDeserializer::deserialize("StorageEncrypted", stack)?);
}
"VpcId" => {
obj.vpc_id = Some(StringDeserializer::deserialize("VpcId", stack)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DBClusterSnapshotAttribute {
pub attribute_name: Option<String>,
pub attribute_values: Option<Vec<String>>,
}
struct DBClusterSnapshotAttributeDeserializer;
impl DBClusterSnapshotAttributeDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DBClusterSnapshotAttribute, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = DBClusterSnapshotAttribute::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[..] {
"AttributeName" => {
obj.attribute_name =
Some(StringDeserializer::deserialize("AttributeName", stack)?);
}
"AttributeValues" => {
obj.attribute_values = match obj.attribute_values {
Some(ref mut existing) => {
existing.extend(AttributeValueListDeserializer::deserialize(
"AttributeValues",
stack,
)?);
Some(existing.to_vec())
}
None => Some(AttributeValueListDeserializer::deserialize(
"AttributeValues",
stack,
)?),
};
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct DBClusterSnapshotAttributeListDeserializer;
impl DBClusterSnapshotAttributeListDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<DBClusterSnapshotAttribute>, XmlParseError> {
let mut obj = vec![];
start_element(tag_name, stack)?;
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "DBClusterSnapshotAttribute" {
obj.push(DBClusterSnapshotAttributeDeserializer::deserialize(
"DBClusterSnapshotAttribute",
stack,
)?);
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
end_element(tag_name, stack)?;
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DBClusterSnapshotAttributesResult {
pub db_cluster_snapshot_attributes: Option<Vec<DBClusterSnapshotAttribute>>,
pub db_cluster_snapshot_identifier: Option<String>,
}
struct DBClusterSnapshotAttributesResultDeserializer;
impl DBClusterSnapshotAttributesResultDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DBClusterSnapshotAttributesResult, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = DBClusterSnapshotAttributesResult::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[..] {
"DBClusterSnapshotAttributes" => {
obj.db_cluster_snapshot_attributes = match obj
.db_cluster_snapshot_attributes
{
Some(ref mut existing) => {
existing.extend(
DBClusterSnapshotAttributeListDeserializer::deserialize(
"DBClusterSnapshotAttributes",
stack,
)?,
);
Some(existing.to_vec())
}
None => Some(DBClusterSnapshotAttributeListDeserializer::deserialize(
"DBClusterSnapshotAttributes",
stack,
)?),
};
}
"DBClusterSnapshotIdentifier" => {
obj.db_cluster_snapshot_identifier = Some(StringDeserializer::deserialize(
"DBClusterSnapshotIdentifier",
stack,
)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct DBClusterSnapshotListDeserializer;
impl DBClusterSnapshotListDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<DBClusterSnapshot>, XmlParseError> {
let mut obj = vec![];
start_element(tag_name, stack)?;
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "DBClusterSnapshot" {
obj.push(DBClusterSnapshotDeserializer::deserialize(
"DBClusterSnapshot",
stack,
)?);
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
end_element(tag_name, stack)?;
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DBClusterSnapshotMessage {
pub db_cluster_snapshots: Option<Vec<DBClusterSnapshot>>,
pub marker: Option<String>,
}
struct DBClusterSnapshotMessageDeserializer;
impl DBClusterSnapshotMessageDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DBClusterSnapshotMessage, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = DBClusterSnapshotMessage::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[..] {
"DBClusterSnapshots" => {
obj.db_cluster_snapshots = match obj.db_cluster_snapshots {
Some(ref mut existing) => {
existing.extend(DBClusterSnapshotListDeserializer::deserialize(
"DBClusterSnapshots",
stack,
)?);
Some(existing.to_vec())
}
None => Some(DBClusterSnapshotListDeserializer::deserialize(
"DBClusterSnapshots",
stack,
)?),
};
}
"Marker" => {
obj.marker = Some(StringDeserializer::deserialize("Marker", stack)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DBEngineVersion {
pub db_engine_description: Option<String>,
pub db_engine_version_description: Option<String>,
pub db_parameter_group_family: Option<String>,
pub default_character_set: Option<CharacterSet>,
pub engine: Option<String>,
pub engine_version: Option<String>,
pub exportable_log_types: Option<Vec<String>>,
pub supported_character_sets: Option<Vec<CharacterSet>>,
pub supported_timezones: Option<Vec<Timezone>>,
pub supports_log_exports_to_cloudwatch_logs: Option<bool>,
pub supports_read_replica: Option<bool>,
pub valid_upgrade_target: Option<Vec<UpgradeTarget>>,
}
struct DBEngineVersionDeserializer;
impl DBEngineVersionDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DBEngineVersion, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = DBEngineVersion::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[..] {
"DBEngineDescription" => {
obj.db_engine_description = Some(StringDeserializer::deserialize(
"DBEngineDescription",
stack,
)?);
}
"DBEngineVersionDescription" => {
obj.db_engine_version_description = Some(StringDeserializer::deserialize(
"DBEngineVersionDescription",
stack,
)?);
}
"DBParameterGroupFamily" => {
obj.db_parameter_group_family = Some(StringDeserializer::deserialize(
"DBParameterGroupFamily",
stack,
)?);
}
"DefaultCharacterSet" => {
obj.default_character_set = Some(CharacterSetDeserializer::deserialize(
"DefaultCharacterSet",
stack,
)?);
}
"Engine" => {
obj.engine = Some(StringDeserializer::deserialize("Engine", stack)?);
}
"EngineVersion" => {
obj.engine_version =
Some(StringDeserializer::deserialize("EngineVersion", stack)?);
}
"ExportableLogTypes" => {
obj.exportable_log_types = match obj.exportable_log_types {
Some(ref mut existing) => {
existing.extend(LogTypeListDeserializer::deserialize(
"ExportableLogTypes",
stack,
)?);
Some(existing.to_vec())
}
None => Some(LogTypeListDeserializer::deserialize(
"ExportableLogTypes",
stack,
)?),
};
}
"SupportedCharacterSets" => {
obj.supported_character_sets = match obj.supported_character_sets {
Some(ref mut existing) => {
existing.extend(
SupportedCharacterSetsListDeserializer::deserialize(
"SupportedCharacterSets",
stack,
)?,
);
Some(existing.to_vec())
}
None => Some(SupportedCharacterSetsListDeserializer::deserialize(
"SupportedCharacterSets",
stack,
)?),
};
}
"SupportedTimezones" => {
obj.supported_timezones = match obj.supported_timezones {
Some(ref mut existing) => {
existing.extend(SupportedTimezonesListDeserializer::deserialize(
"SupportedTimezones",
stack,
)?);
Some(existing.to_vec())
}
None => Some(SupportedTimezonesListDeserializer::deserialize(
"SupportedTimezones",
stack,
)?),
};
}
"SupportsLogExportsToCloudwatchLogs" => {
obj.supports_log_exports_to_cloudwatch_logs =
Some(BooleanDeserializer::deserialize(
"SupportsLogExportsToCloudwatchLogs",
stack,
)?);
}
"SupportsReadReplica" => {
obj.supports_read_replica = Some(BooleanDeserializer::deserialize(
"SupportsReadReplica",
stack,
)?);
}
"ValidUpgradeTarget" => {
obj.valid_upgrade_target = match obj.valid_upgrade_target {
Some(ref mut existing) => {
existing.extend(ValidUpgradeTargetListDeserializer::deserialize(
"ValidUpgradeTarget",
stack,
)?);
Some(existing.to_vec())
}
None => Some(ValidUpgradeTargetListDeserializer::deserialize(
"ValidUpgradeTarget",
stack,
)?),
};
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct DBEngineVersionListDeserializer;
impl DBEngineVersionListDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<DBEngineVersion>, XmlParseError> {
let mut obj = vec![];
start_element(tag_name, stack)?;
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "DBEngineVersion" {
obj.push(DBEngineVersionDeserializer::deserialize(
"DBEngineVersion",
stack,
)?);
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
end_element(tag_name, stack)?;
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DBEngineVersionMessage {
pub db_engine_versions: Option<Vec<DBEngineVersion>>,
pub marker: Option<String>,
}
struct DBEngineVersionMessageDeserializer;
impl DBEngineVersionMessageDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DBEngineVersionMessage, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = DBEngineVersionMessage::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[..] {
"DBEngineVersions" => {
obj.db_engine_versions = match obj.db_engine_versions {
Some(ref mut existing) => {
existing.extend(DBEngineVersionListDeserializer::deserialize(
"DBEngineVersions",
stack,
)?);
Some(existing.to_vec())
}
None => Some(DBEngineVersionListDeserializer::deserialize(
"DBEngineVersions",
stack,
)?),
};
}
"Marker" => {
obj.marker = Some(StringDeserializer::deserialize("Marker", stack)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DBInstance {
pub allocated_storage: Option<i64>,
pub auto_minor_version_upgrade: Option<bool>,
pub availability_zone: Option<String>,
pub backup_retention_period: Option<i64>,
pub ca_certificate_identifier: Option<String>,
pub character_set_name: Option<String>,
pub copy_tags_to_snapshot: Option<bool>,
pub db_cluster_identifier: Option<String>,
pub db_instance_arn: Option<String>,
pub db_instance_class: Option<String>,
pub db_instance_identifier: Option<String>,
pub db_instance_status: Option<String>,
pub db_name: Option<String>,
pub db_parameter_groups: Option<Vec<DBParameterGroupStatus>>,
pub db_security_groups: Option<Vec<DBSecurityGroupMembership>>,
pub db_subnet_group: Option<DBSubnetGroup>,
pub db_instance_port: Option<i64>,
pub dbi_resource_id: Option<String>,
pub domain_memberships: Option<Vec<DomainMembership>>,
pub enabled_cloudwatch_logs_exports: Option<Vec<String>>,
pub endpoint: Option<Endpoint>,
pub engine: Option<String>,
pub engine_version: Option<String>,
pub enhanced_monitoring_resource_arn: Option<String>,
pub iam_database_authentication_enabled: Option<bool>,
pub instance_create_time: Option<String>,
pub iops: Option<i64>,
pub kms_key_id: Option<String>,
pub latest_restorable_time: Option<String>,
pub license_model: Option<String>,
pub master_username: Option<String>,
pub monitoring_interval: Option<i64>,
pub monitoring_role_arn: Option<String>,
pub multi_az: Option<bool>,
pub option_group_memberships: Option<Vec<OptionGroupMembership>>,
pub pending_modified_values: Option<PendingModifiedValues>,
pub performance_insights_enabled: Option<bool>,
pub performance_insights_kms_key_id: Option<String>,
pub preferred_backup_window: Option<String>,
pub preferred_maintenance_window: Option<String>,
pub promotion_tier: Option<i64>,
pub read_replica_db_cluster_identifiers: Option<Vec<String>>,
pub read_replica_db_instance_identifiers: Option<Vec<String>>,
pub read_replica_source_db_instance_identifier: Option<String>,
pub secondary_availability_zone: Option<String>,
pub status_infos: Option<Vec<DBInstanceStatusInfo>>,
pub storage_encrypted: Option<bool>,
pub storage_type: Option<String>,
pub tde_credential_arn: Option<String>,
pub timezone: Option<String>,
pub vpc_security_groups: Option<Vec<VpcSecurityGroupMembership>>,
}
struct DBInstanceDeserializer;
impl DBInstanceDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DBInstance, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = DBInstance::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[..] {
"AllocatedStorage" => {
obj.allocated_storage =
Some(IntegerDeserializer::deserialize("AllocatedStorage", stack)?);
}
"AutoMinorVersionUpgrade" => {
obj.auto_minor_version_upgrade = Some(BooleanDeserializer::deserialize(
"AutoMinorVersionUpgrade",
stack,
)?);
}
"AvailabilityZone" => {
obj.availability_zone =
Some(StringDeserializer::deserialize("AvailabilityZone", stack)?);
}
"BackupRetentionPeriod" => {
obj.backup_retention_period = Some(IntegerDeserializer::deserialize(
"BackupRetentionPeriod",
stack,
)?);
}
"CACertificateIdentifier" => {
obj.ca_certificate_identifier = Some(StringDeserializer::deserialize(
"CACertificateIdentifier",
stack,
)?);
}
"CharacterSetName" => {
obj.character_set_name =
Some(StringDeserializer::deserialize("CharacterSetName", stack)?);
}
"CopyTagsToSnapshot" => {
obj.copy_tags_to_snapshot = Some(BooleanDeserializer::deserialize(
"CopyTagsToSnapshot",
stack,
)?);
}
"DBClusterIdentifier" => {
obj.db_cluster_identifier = Some(StringDeserializer::deserialize(
"DBClusterIdentifier",
stack,
)?);
}
"DBInstanceArn" => {
obj.db_instance_arn =
Some(StringDeserializer::deserialize("DBInstanceArn", stack)?);
}
"DBInstanceClass" => {
obj.db_instance_class =
Some(StringDeserializer::deserialize("DBInstanceClass", stack)?);
}
"DBInstanceIdentifier" => {
obj.db_instance_identifier = Some(StringDeserializer::deserialize(
"DBInstanceIdentifier",
stack,
)?);
}
"DBInstanceStatus" => {
obj.db_instance_status =
Some(StringDeserializer::deserialize("DBInstanceStatus", stack)?);
}
"DBName" => {
obj.db_name = Some(StringDeserializer::deserialize("DBName", stack)?);
}
"DBParameterGroups" => {
obj.db_parameter_groups = match obj.db_parameter_groups {
Some(ref mut existing) => {
existing.extend(
DBParameterGroupStatusListDeserializer::deserialize(
"DBParameterGroups",
stack,
)?,
);
Some(existing.to_vec())
}
None => Some(DBParameterGroupStatusListDeserializer::deserialize(
"DBParameterGroups",
stack,
)?),
};
}
"DBSecurityGroups" => {
obj.db_security_groups = match obj.db_security_groups {
Some(ref mut existing) => {
existing.extend(
DBSecurityGroupMembershipListDeserializer::deserialize(
"DBSecurityGroups",
stack,
)?,
);
Some(existing.to_vec())
}
None => Some(DBSecurityGroupMembershipListDeserializer::deserialize(
"DBSecurityGroups",
stack,
)?),
};
}
"DBSubnetGroup" => {
obj.db_subnet_group = Some(DBSubnetGroupDeserializer::deserialize(
"DBSubnetGroup",
stack,
)?);
}
"DbInstancePort" => {
obj.db_instance_port =
Some(IntegerDeserializer::deserialize("DbInstancePort", stack)?);
}
"DbiResourceId" => {
obj.dbi_resource_id =
Some(StringDeserializer::deserialize("DbiResourceId", stack)?);
}
"DomainMemberships" => {
obj.domain_memberships = match obj.domain_memberships {
Some(ref mut existing) => {
existing.extend(DomainMembershipListDeserializer::deserialize(
"DomainMemberships",
stack,
)?);
Some(existing.to_vec())
}
None => Some(DomainMembershipListDeserializer::deserialize(
"DomainMemberships",
stack,
)?),
};
}
"EnabledCloudwatchLogsExports" => {
obj.enabled_cloudwatch_logs_exports =
match obj.enabled_cloudwatch_logs_exports {
Some(ref mut existing) => {
existing.extend(LogTypeListDeserializer::deserialize(
"EnabledCloudwatchLogsExports",
stack,
)?);
Some(existing.to_vec())
}
None => Some(LogTypeListDeserializer::deserialize(
"EnabledCloudwatchLogsExports",
stack,
)?),
};
}
"Endpoint" => {
obj.endpoint = Some(EndpointDeserializer::deserialize("Endpoint", stack)?);
}
"Engine" => {
obj.engine = Some(StringDeserializer::deserialize("Engine", stack)?);
}
"EngineVersion" => {
obj.engine_version =
Some(StringDeserializer::deserialize("EngineVersion", stack)?);
}
"EnhancedMonitoringResourceArn" => {
obj.enhanced_monitoring_resource_arn =
Some(StringDeserializer::deserialize(
"EnhancedMonitoringResourceArn",
stack,
)?);
}
"IAMDatabaseAuthenticationEnabled" => {
obj.iam_database_authentication_enabled =
Some(BooleanDeserializer::deserialize(
"IAMDatabaseAuthenticationEnabled",
stack,
)?);
}
"InstanceCreateTime" => {
obj.instance_create_time = Some(TStampDeserializer::deserialize(
"InstanceCreateTime",
stack,
)?);
}
"Iops" => {
obj.iops = Some(IntegerOptionalDeserializer::deserialize("Iops", stack)?);
}
"KmsKeyId" => {
obj.kms_key_id = Some(StringDeserializer::deserialize("KmsKeyId", stack)?);
}
"LatestRestorableTime" => {
obj.latest_restorable_time = Some(TStampDeserializer::deserialize(
"LatestRestorableTime",
stack,
)?);
}
"LicenseModel" => {
obj.license_model =
Some(StringDeserializer::deserialize("LicenseModel", stack)?);
}
"MasterUsername" => {
obj.master_username =
Some(StringDeserializer::deserialize("MasterUsername", stack)?);
}
"MonitoringInterval" => {
obj.monitoring_interval = Some(IntegerOptionalDeserializer::deserialize(
"MonitoringInterval",
stack,
)?);
}
"MonitoringRoleArn" => {
obj.monitoring_role_arn =
Some(StringDeserializer::deserialize("MonitoringRoleArn", stack)?);
}
"MultiAZ" => {
obj.multi_az = Some(BooleanDeserializer::deserialize("MultiAZ", stack)?);
}
"OptionGroupMemberships" => {
obj.option_group_memberships = match obj.option_group_memberships {
Some(ref mut existing) => {
existing.extend(
OptionGroupMembershipListDeserializer::deserialize(
"OptionGroupMemberships",
stack,
)?,
);
Some(existing.to_vec())
}
None => Some(OptionGroupMembershipListDeserializer::deserialize(
"OptionGroupMemberships",
stack,
)?),
};
}
"PendingModifiedValues" => {
obj.pending_modified_values =
Some(PendingModifiedValuesDeserializer::deserialize(
"PendingModifiedValues",
stack,
)?);
}
"PerformanceInsightsEnabled" => {
obj.performance_insights_enabled =
Some(BooleanOptionalDeserializer::deserialize(
"PerformanceInsightsEnabled",
stack,
)?);
}
"PerformanceInsightsKMSKeyId" => {
obj.performance_insights_kms_key_id = Some(
StringDeserializer::deserialize("PerformanceInsightsKMSKeyId", stack)?,
);
}
"PreferredBackupWindow" => {
obj.preferred_backup_window = Some(StringDeserializer::deserialize(
"PreferredBackupWindow",
stack,
)?);
}
"PreferredMaintenanceWindow" => {
obj.preferred_maintenance_window = Some(StringDeserializer::deserialize(
"PreferredMaintenanceWindow",
stack,
)?);
}
"PromotionTier" => {
obj.promotion_tier = Some(IntegerOptionalDeserializer::deserialize(
"PromotionTier",
stack,
)?);
}
"ReadReplicaDBClusterIdentifiers" => {
obj.read_replica_db_cluster_identifiers = match obj
.read_replica_db_cluster_identifiers
{
Some(ref mut existing) => {
existing.extend(
ReadReplicaDBClusterIdentifierListDeserializer::deserialize(
"ReadReplicaDBClusterIdentifiers",
stack,
)?,
);
Some(existing.to_vec())
}
None => {
Some(ReadReplicaDBClusterIdentifierListDeserializer::deserialize(
"ReadReplicaDBClusterIdentifiers",
stack,
)?)
}
};
}
"ReadReplicaDBInstanceIdentifiers" => {
obj.read_replica_db_instance_identifiers = match obj
.read_replica_db_instance_identifiers
{
Some(ref mut existing) => {
existing.extend(
ReadReplicaDBInstanceIdentifierListDeserializer::deserialize(
"ReadReplicaDBInstanceIdentifiers",
stack,
)?,
);
Some(existing.to_vec())
}
None => Some(
ReadReplicaDBInstanceIdentifierListDeserializer::deserialize(
"ReadReplicaDBInstanceIdentifiers",
stack,
)?,
),
};
}
"ReadReplicaSourceDBInstanceIdentifier" => {
obj.read_replica_source_db_instance_identifier =
Some(StringDeserializer::deserialize(
"ReadReplicaSourceDBInstanceIdentifier",
stack,
)?);
}
"SecondaryAvailabilityZone" => {
obj.secondary_availability_zone = Some(StringDeserializer::deserialize(
"SecondaryAvailabilityZone",
stack,
)?);
}
"StatusInfos" => {
obj.status_infos = match obj.status_infos {
Some(ref mut existing) => {
existing.extend(DBInstanceStatusInfoListDeserializer::deserialize(
"StatusInfos",
stack,
)?);
Some(existing.to_vec())
}
None => Some(DBInstanceStatusInfoListDeserializer::deserialize(
"StatusInfos",
stack,
)?),
};
}
"StorageEncrypted" => {
obj.storage_encrypted =
Some(BooleanDeserializer::deserialize("StorageEncrypted", stack)?);
}
"StorageType" => {
obj.storage_type =
Some(StringDeserializer::deserialize("StorageType", stack)?);
}
"TdeCredentialArn" => {
obj.tde_credential_arn =
Some(StringDeserializer::deserialize("TdeCredentialArn", stack)?);
}
"Timezone" => {
obj.timezone = Some(StringDeserializer::deserialize("Timezone", stack)?);
}
"VpcSecurityGroups" => {
obj.vpc_security_groups = match obj.vpc_security_groups {
Some(ref mut existing) => {
existing.extend(
VpcSecurityGroupMembershipListDeserializer::deserialize(
"VpcSecurityGroups",
stack,
)?,
);
Some(existing.to_vec())
}
None => Some(VpcSecurityGroupMembershipListDeserializer::deserialize(
"VpcSecurityGroups",
stack,
)?),
};
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct DBInstanceListDeserializer;
impl DBInstanceListDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<DBInstance>, XmlParseError> {
let mut obj = vec![];
start_element(tag_name, stack)?;
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "DBInstance" {
obj.push(DBInstanceDeserializer::deserialize("DBInstance", stack)?);
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
end_element(tag_name, stack)?;
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DBInstanceMessage {
pub db_instances: Option<Vec<DBInstance>>,
pub marker: Option<String>,
}
struct DBInstanceMessageDeserializer;
impl DBInstanceMessageDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DBInstanceMessage, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = DBInstanceMessage::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[..] {
"DBInstances" => {
obj.db_instances = match obj.db_instances {
Some(ref mut existing) => {
existing.extend(DBInstanceListDeserializer::deserialize(
"DBInstances",
stack,
)?);
Some(existing.to_vec())
}
None => Some(DBInstanceListDeserializer::deserialize(
"DBInstances",
stack,
)?),
};
}
"Marker" => {
obj.marker = Some(StringDeserializer::deserialize("Marker", stack)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DBInstanceStatusInfo {
pub message: Option<String>,
pub normal: Option<bool>,
pub status: Option<String>,
pub status_type: Option<String>,
}
struct DBInstanceStatusInfoDeserializer;
impl DBInstanceStatusInfoDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DBInstanceStatusInfo, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = DBInstanceStatusInfo::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[..] {
"Message" => {
obj.message = Some(StringDeserializer::deserialize("Message", stack)?);
}
"Normal" => {
obj.normal = Some(BooleanDeserializer::deserialize("Normal", stack)?);
}
"Status" => {
obj.status = Some(StringDeserializer::deserialize("Status", stack)?);
}
"StatusType" => {
obj.status_type =
Some(StringDeserializer::deserialize("StatusType", stack)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct DBInstanceStatusInfoListDeserializer;
impl DBInstanceStatusInfoListDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<DBInstanceStatusInfo>, XmlParseError> {
let mut obj = vec![];
start_element(tag_name, stack)?;
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "DBInstanceStatusInfo" {
obj.push(DBInstanceStatusInfoDeserializer::deserialize(
"DBInstanceStatusInfo",
stack,
)?);
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
end_element(tag_name, stack)?;
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DBParameterGroup {
pub db_parameter_group_arn: Option<String>,
pub db_parameter_group_family: Option<String>,
pub db_parameter_group_name: Option<String>,
pub description: Option<String>,
}
struct DBParameterGroupDeserializer;
impl DBParameterGroupDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DBParameterGroup, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = DBParameterGroup::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[..] {
"DBParameterGroupArn" => {
obj.db_parameter_group_arn = Some(StringDeserializer::deserialize(
"DBParameterGroupArn",
stack,
)?);
}
"DBParameterGroupFamily" => {
obj.db_parameter_group_family = Some(StringDeserializer::deserialize(
"DBParameterGroupFamily",
stack,
)?);
}
"DBParameterGroupName" => {
obj.db_parameter_group_name = Some(StringDeserializer::deserialize(
"DBParameterGroupName",
stack,
)?);
}
"Description" => {
obj.description =
Some(StringDeserializer::deserialize("Description", stack)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DBParameterGroupDetails {
pub marker: Option<String>,
pub parameters: Option<Vec<Parameter>>,
}
struct DBParameterGroupDetailsDeserializer;
impl DBParameterGroupDetailsDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DBParameterGroupDetails, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = DBParameterGroupDetails::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(StringDeserializer::deserialize("Marker", stack)?);
}
"Parameters" => {
obj.parameters = match obj.parameters {
Some(ref mut existing) => {
existing.extend(ParametersListDeserializer::deserialize(
"Parameters",
stack,
)?);
Some(existing.to_vec())
}
None => Some(ParametersListDeserializer::deserialize(
"Parameters",
stack,
)?),
};
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct DBParameterGroupListDeserializer;
impl DBParameterGroupListDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<DBParameterGroup>, XmlParseError> {
let mut obj = vec![];
start_element(tag_name, stack)?;
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "DBParameterGroup" {
obj.push(DBParameterGroupDeserializer::deserialize(
"DBParameterGroup",
stack,
)?);
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
end_element(tag_name, stack)?;
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DBParameterGroupNameMessage {
pub db_parameter_group_name: Option<String>,
}
struct DBParameterGroupNameMessageDeserializer;
impl DBParameterGroupNameMessageDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DBParameterGroupNameMessage, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = DBParameterGroupNameMessage::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[..] {
"DBParameterGroupName" => {
obj.db_parameter_group_name = Some(StringDeserializer::deserialize(
"DBParameterGroupName",
stack,
)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DBParameterGroupStatus {
pub db_parameter_group_name: Option<String>,
pub parameter_apply_status: Option<String>,
}
struct DBParameterGroupStatusDeserializer;
impl DBParameterGroupStatusDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DBParameterGroupStatus, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = DBParameterGroupStatus::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[..] {
"DBParameterGroupName" => {
obj.db_parameter_group_name = Some(StringDeserializer::deserialize(
"DBParameterGroupName",
stack,
)?);
}
"ParameterApplyStatus" => {
obj.parameter_apply_status = Some(StringDeserializer::deserialize(
"ParameterApplyStatus",
stack,
)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct DBParameterGroupStatusListDeserializer;
impl DBParameterGroupStatusListDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<DBParameterGroupStatus>, XmlParseError> {
let mut obj = vec![];
start_element(tag_name, stack)?;
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "DBParameterGroup" {
obj.push(DBParameterGroupStatusDeserializer::deserialize(
"DBParameterGroup",
stack,
)?);
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
end_element(tag_name, stack)?;
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DBParameterGroupsMessage {
pub db_parameter_groups: Option<Vec<DBParameterGroup>>,
pub marker: Option<String>,
}
struct DBParameterGroupsMessageDeserializer;
impl DBParameterGroupsMessageDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DBParameterGroupsMessage, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = DBParameterGroupsMessage::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[..] {
"DBParameterGroups" => {
obj.db_parameter_groups = match obj.db_parameter_groups {
Some(ref mut existing) => {
existing.extend(DBParameterGroupListDeserializer::deserialize(
"DBParameterGroups",
stack,
)?);
Some(existing.to_vec())
}
None => Some(DBParameterGroupListDeserializer::deserialize(
"DBParameterGroups",
stack,
)?),
};
}
"Marker" => {
obj.marker = Some(StringDeserializer::deserialize("Marker", stack)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DBSecurityGroupMembership {
pub db_security_group_name: Option<String>,
pub status: Option<String>,
}
struct DBSecurityGroupMembershipDeserializer;
impl DBSecurityGroupMembershipDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DBSecurityGroupMembership, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = DBSecurityGroupMembership::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[..] {
"DBSecurityGroupName" => {
obj.db_security_group_name = Some(StringDeserializer::deserialize(
"DBSecurityGroupName",
stack,
)?);
}
"Status" => {
obj.status = Some(StringDeserializer::deserialize("Status", stack)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct DBSecurityGroupMembershipListDeserializer;
impl DBSecurityGroupMembershipListDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<DBSecurityGroupMembership>, XmlParseError> {
let mut obj = vec![];
start_element(tag_name, stack)?;
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "DBSecurityGroup" {
obj.push(DBSecurityGroupMembershipDeserializer::deserialize(
"DBSecurityGroup",
stack,
)?);
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
end_element(tag_name, stack)?;
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
struct DBSecurityGroupNameListSerializer;
impl DBSecurityGroupNameListSerializer {
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 DBSubnetGroup {
pub db_subnet_group_arn: Option<String>,
pub db_subnet_group_description: Option<String>,
pub db_subnet_group_name: Option<String>,
pub subnet_group_status: Option<String>,
pub subnets: Option<Vec<Subnet>>,
pub vpc_id: Option<String>,
}
struct DBSubnetGroupDeserializer;
impl DBSubnetGroupDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DBSubnetGroup, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = DBSubnetGroup::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[..] {
"DBSubnetGroupArn" => {
obj.db_subnet_group_arn =
Some(StringDeserializer::deserialize("DBSubnetGroupArn", stack)?);
}
"DBSubnetGroupDescription" => {
obj.db_subnet_group_description = Some(StringDeserializer::deserialize(
"DBSubnetGroupDescription",
stack,
)?);
}
"DBSubnetGroupName" => {
obj.db_subnet_group_name =
Some(StringDeserializer::deserialize("DBSubnetGroupName", stack)?);
}
"SubnetGroupStatus" => {
obj.subnet_group_status =
Some(StringDeserializer::deserialize("SubnetGroupStatus", stack)?);
}
"Subnets" => {
obj.subnets = match obj.subnets {
Some(ref mut existing) => {
existing
.extend(SubnetListDeserializer::deserialize("Subnets", stack)?);
Some(existing.to_vec())
}
None => Some(SubnetListDeserializer::deserialize("Subnets", stack)?),
};
}
"VpcId" => {
obj.vpc_id = Some(StringDeserializer::deserialize("VpcId", stack)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DBSubnetGroupMessage {
pub db_subnet_groups: Option<Vec<DBSubnetGroup>>,
pub marker: Option<String>,
}
struct DBSubnetGroupMessageDeserializer;
impl DBSubnetGroupMessageDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DBSubnetGroupMessage, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = DBSubnetGroupMessage::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[..] {
"DBSubnetGroups" => {
obj.db_subnet_groups = match obj.db_subnet_groups {
Some(ref mut existing) => {
existing.extend(DBSubnetGroupsDeserializer::deserialize(
"DBSubnetGroups",
stack,
)?);
Some(existing.to_vec())
}
None => Some(DBSubnetGroupsDeserializer::deserialize(
"DBSubnetGroups",
stack,
)?),
};
}
"Marker" => {
obj.marker = Some(StringDeserializer::deserialize("Marker", stack)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct DBSubnetGroupsDeserializer;
impl DBSubnetGroupsDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<DBSubnetGroup>, XmlParseError> {
let mut obj = vec![];
start_element(tag_name, stack)?;
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "DBSubnetGroup" {
obj.push(DBSubnetGroupDeserializer::deserialize(
"DBSubnetGroup",
stack,
)?);
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
end_element(tag_name, stack)?;
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DeleteDBClusterMessage {
pub db_cluster_identifier: String,
pub final_db_snapshot_identifier: Option<String>,
pub skip_final_snapshot: Option<bool>,
}
struct DeleteDBClusterMessageSerializer;
impl DeleteDBClusterMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DeleteDBClusterMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "DBClusterIdentifier"),
&obj.db_cluster_identifier,
);
if let Some(ref field_value) = obj.final_db_snapshot_identifier {
params.put(
&format!("{}{}", prefix, "FinalDBSnapshotIdentifier"),
&field_value,
);
}
if let Some(ref field_value) = obj.skip_final_snapshot {
params.put(
&format!("{}{}", prefix, "SkipFinalSnapshot"),
&field_value.to_string(),
);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DeleteDBClusterParameterGroupMessage {
pub db_cluster_parameter_group_name: String,
}
struct DeleteDBClusterParameterGroupMessageSerializer;
impl DeleteDBClusterParameterGroupMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DeleteDBClusterParameterGroupMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "DBClusterParameterGroupName"),
&obj.db_cluster_parameter_group_name,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DeleteDBClusterResult {
pub db_cluster: Option<DBCluster>,
}
struct DeleteDBClusterResultDeserializer;
impl DeleteDBClusterResultDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DeleteDBClusterResult, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = DeleteDBClusterResult::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[..] {
"DBCluster" => {
obj.db_cluster =
Some(DBClusterDeserializer::deserialize("DBCluster", stack)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DeleteDBClusterSnapshotMessage {
pub db_cluster_snapshot_identifier: String,
}
struct DeleteDBClusterSnapshotMessageSerializer;
impl DeleteDBClusterSnapshotMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DeleteDBClusterSnapshotMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "DBClusterSnapshotIdentifier"),
&obj.db_cluster_snapshot_identifier,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DeleteDBClusterSnapshotResult {
pub db_cluster_snapshot: Option<DBClusterSnapshot>,
}
struct DeleteDBClusterSnapshotResultDeserializer;
impl DeleteDBClusterSnapshotResultDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DeleteDBClusterSnapshotResult, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = DeleteDBClusterSnapshotResult::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[..] {
"DBClusterSnapshot" => {
obj.db_cluster_snapshot = Some(DBClusterSnapshotDeserializer::deserialize(
"DBClusterSnapshot",
stack,
)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DeleteDBInstanceMessage {
pub db_instance_identifier: String,
pub final_db_snapshot_identifier: Option<String>,
pub skip_final_snapshot: Option<bool>,
}
struct DeleteDBInstanceMessageSerializer;
impl DeleteDBInstanceMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DeleteDBInstanceMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "DBInstanceIdentifier"),
&obj.db_instance_identifier,
);
if let Some(ref field_value) = obj.final_db_snapshot_identifier {
params.put(
&format!("{}{}", prefix, "FinalDBSnapshotIdentifier"),
&field_value,
);
}
if let Some(ref field_value) = obj.skip_final_snapshot {
params.put(
&format!("{}{}", prefix, "SkipFinalSnapshot"),
&field_value.to_string(),
);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DeleteDBInstanceResult {
pub db_instance: Option<DBInstance>,
}
struct DeleteDBInstanceResultDeserializer;
impl DeleteDBInstanceResultDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DeleteDBInstanceResult, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = DeleteDBInstanceResult::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[..] {
"DBInstance" => {
obj.db_instance =
Some(DBInstanceDeserializer::deserialize("DBInstance", stack)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DeleteDBParameterGroupMessage {
pub db_parameter_group_name: String,
}
struct DeleteDBParameterGroupMessageSerializer;
impl DeleteDBParameterGroupMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DeleteDBParameterGroupMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "DBParameterGroupName"),
&obj.db_parameter_group_name,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DeleteDBSubnetGroupMessage {
pub db_subnet_group_name: String,
}
struct DeleteDBSubnetGroupMessageSerializer;
impl DeleteDBSubnetGroupMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DeleteDBSubnetGroupMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "DBSubnetGroupName"),
&obj.db_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 DeleteEventSubscriptionResult {
pub event_subscription: Option<EventSubscription>,
}
struct DeleteEventSubscriptionResultDeserializer;
impl DeleteEventSubscriptionResultDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DeleteEventSubscriptionResult, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = DeleteEventSubscriptionResult::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(EventSubscriptionDeserializer::deserialize(
"EventSubscription",
stack,
)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeDBClusterParameterGroupsMessage {
pub db_cluster_parameter_group_name: Option<String>,
pub filters: Option<Vec<Filter>>,
pub marker: Option<String>,
pub max_records: Option<i64>,
}
struct DescribeDBClusterParameterGroupsMessageSerializer;
impl DescribeDBClusterParameterGroupsMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeDBClusterParameterGroupsMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.db_cluster_parameter_group_name {
params.put(
&format!("{}{}", prefix, "DBClusterParameterGroupName"),
&field_value,
);
}
if let Some(ref field_value) = obj.filters {
FilterListSerializer::serialize(
params,
&format!("{}{}", prefix, "Filter"),
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 DescribeDBClusterParametersMessage {
pub db_cluster_parameter_group_name: String,
pub filters: Option<Vec<Filter>>,
pub marker: Option<String>,
pub max_records: Option<i64>,
pub source: Option<String>,
}
struct DescribeDBClusterParametersMessageSerializer;
impl DescribeDBClusterParametersMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeDBClusterParametersMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "DBClusterParameterGroupName"),
&obj.db_cluster_parameter_group_name,
);
if let Some(ref field_value) = obj.filters {
FilterListSerializer::serialize(
params,
&format!("{}{}", prefix, "Filter"),
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 {
params.put(&format!("{}{}", prefix, "Source"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeDBClusterSnapshotAttributesMessage {
pub db_cluster_snapshot_identifier: String,
}
struct DescribeDBClusterSnapshotAttributesMessageSerializer;
impl DescribeDBClusterSnapshotAttributesMessageSerializer {
fn serialize(
params: &mut Params,
name: &str,
obj: &DescribeDBClusterSnapshotAttributesMessage,
) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "DBClusterSnapshotIdentifier"),
&obj.db_cluster_snapshot_identifier,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeDBClusterSnapshotAttributesResult {
pub db_cluster_snapshot_attributes_result: Option<DBClusterSnapshotAttributesResult>,
}
struct DescribeDBClusterSnapshotAttributesResultDeserializer;
impl DescribeDBClusterSnapshotAttributesResultDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeDBClusterSnapshotAttributesResult, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = DescribeDBClusterSnapshotAttributesResult::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[..] {
"DBClusterSnapshotAttributesResult" => {
obj.db_cluster_snapshot_attributes_result =
Some(DBClusterSnapshotAttributesResultDeserializer::deserialize(
"DBClusterSnapshotAttributesResult",
stack,
)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeDBClusterSnapshotsMessage {
pub db_cluster_identifier: Option<String>,
pub db_cluster_snapshot_identifier: Option<String>,
pub filters: Option<Vec<Filter>>,
pub include_public: Option<bool>,
pub include_shared: Option<bool>,
pub marker: Option<String>,
pub max_records: Option<i64>,
pub snapshot_type: Option<String>,
}
struct DescribeDBClusterSnapshotsMessageSerializer;
impl DescribeDBClusterSnapshotsMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeDBClusterSnapshotsMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.db_cluster_identifier {
params.put(
&format!("{}{}", prefix, "DBClusterIdentifier"),
&field_value,
);
}
if let Some(ref field_value) = obj.db_cluster_snapshot_identifier {
params.put(
&format!("{}{}", prefix, "DBClusterSnapshotIdentifier"),
&field_value,
);
}
if let Some(ref field_value) = obj.filters {
FilterListSerializer::serialize(
params,
&format!("{}{}", prefix, "Filter"),
field_value,
);
}
if let Some(ref field_value) = obj.include_public {
params.put(
&format!("{}{}", prefix, "IncludePublic"),
&field_value.to_string(),
);
}
if let Some(ref field_value) = obj.include_shared {
params.put(
&format!("{}{}", prefix, "IncludeShared"),
&field_value.to_string(),
);
}
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_type {
params.put(&format!("{}{}", prefix, "SnapshotType"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeDBClustersMessage {
pub db_cluster_identifier: Option<String>,
pub filters: Option<Vec<Filter>>,
pub marker: Option<String>,
pub max_records: Option<i64>,
}
struct DescribeDBClustersMessageSerializer;
impl DescribeDBClustersMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeDBClustersMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.db_cluster_identifier {
params.put(
&format!("{}{}", prefix, "DBClusterIdentifier"),
&field_value,
);
}
if let Some(ref field_value) = obj.filters {
FilterListSerializer::serialize(
params,
&format!("{}{}", prefix, "Filter"),
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 DescribeDBEngineVersionsMessage {
pub db_parameter_group_family: Option<String>,
pub default_only: Option<bool>,
pub engine: Option<String>,
pub engine_version: Option<String>,
pub filters: Option<Vec<Filter>>,
pub list_supported_character_sets: Option<bool>,
pub list_supported_timezones: Option<bool>,
pub marker: Option<String>,
pub max_records: Option<i64>,
}
struct DescribeDBEngineVersionsMessageSerializer;
impl DescribeDBEngineVersionsMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeDBEngineVersionsMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.db_parameter_group_family {
params.put(
&format!("{}{}", prefix, "DBParameterGroupFamily"),
&field_value,
);
}
if let Some(ref field_value) = obj.default_only {
params.put(
&format!("{}{}", prefix, "DefaultOnly"),
&field_value.to_string(),
);
}
if let Some(ref field_value) = obj.engine {
params.put(&format!("{}{}", prefix, "Engine"), &field_value);
}
if let Some(ref field_value) = obj.engine_version {
params.put(&format!("{}{}", prefix, "EngineVersion"), &field_value);
}
if let Some(ref field_value) = obj.filters {
FilterListSerializer::serialize(
params,
&format!("{}{}", prefix, "Filter"),
field_value,
);
}
if let Some(ref field_value) = obj.list_supported_character_sets {
params.put(
&format!("{}{}", prefix, "ListSupportedCharacterSets"),
&field_value.to_string(),
);
}
if let Some(ref field_value) = obj.list_supported_timezones {
params.put(
&format!("{}{}", prefix, "ListSupportedTimezones"),
&field_value.to_string(),
);
}
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 DescribeDBInstancesMessage {
pub db_instance_identifier: Option<String>,
pub filters: Option<Vec<Filter>>,
pub marker: Option<String>,
pub max_records: Option<i64>,
}
struct DescribeDBInstancesMessageSerializer;
impl DescribeDBInstancesMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeDBInstancesMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.db_instance_identifier {
params.put(
&format!("{}{}", prefix, "DBInstanceIdentifier"),
&field_value,
);
}
if let Some(ref field_value) = obj.filters {
FilterListSerializer::serialize(
params,
&format!("{}{}", prefix, "Filter"),
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 DescribeDBParameterGroupsMessage {
pub db_parameter_group_name: Option<String>,
pub filters: Option<Vec<Filter>>,
pub marker: Option<String>,
pub max_records: Option<i64>,
}
struct DescribeDBParameterGroupsMessageSerializer;
impl DescribeDBParameterGroupsMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeDBParameterGroupsMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.db_parameter_group_name {
params.put(
&format!("{}{}", prefix, "DBParameterGroupName"),
&field_value,
);
}
if let Some(ref field_value) = obj.filters {
FilterListSerializer::serialize(
params,
&format!("{}{}", prefix, "Filter"),
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 DescribeDBParametersMessage {
pub db_parameter_group_name: String,
pub filters: Option<Vec<Filter>>,
pub marker: Option<String>,
pub max_records: Option<i64>,
pub source: Option<String>,
}
struct DescribeDBParametersMessageSerializer;
impl DescribeDBParametersMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeDBParametersMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "DBParameterGroupName"),
&obj.db_parameter_group_name,
);
if let Some(ref field_value) = obj.filters {
FilterListSerializer::serialize(
params,
&format!("{}{}", prefix, "Filter"),
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 {
params.put(&format!("{}{}", prefix, "Source"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeDBSubnetGroupsMessage {
pub db_subnet_group_name: Option<String>,
pub filters: Option<Vec<Filter>>,
pub marker: Option<String>,
pub max_records: Option<i64>,
}
struct DescribeDBSubnetGroupsMessageSerializer;
impl DescribeDBSubnetGroupsMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeDBSubnetGroupsMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.db_subnet_group_name {
params.put(&format!("{}{}", prefix, "DBSubnetGroupName"), &field_value);
}
if let Some(ref field_value) = obj.filters {
FilterListSerializer::serialize(
params,
&format!("{}{}", prefix, "Filter"),
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 DescribeEngineDefaultClusterParametersMessage {
pub db_parameter_group_family: String,
pub filters: Option<Vec<Filter>>,
pub marker: Option<String>,
pub max_records: Option<i64>,
}
struct DescribeEngineDefaultClusterParametersMessageSerializer;
impl DescribeEngineDefaultClusterParametersMessageSerializer {
fn serialize(
params: &mut Params,
name: &str,
obj: &DescribeEngineDefaultClusterParametersMessage,
) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "DBParameterGroupFamily"),
&obj.db_parameter_group_family,
);
if let Some(ref field_value) = obj.filters {
FilterListSerializer::serialize(
params,
&format!("{}{}", prefix, "Filter"),
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 DescribeEngineDefaultClusterParametersResult {
pub engine_defaults: Option<EngineDefaults>,
}
struct DescribeEngineDefaultClusterParametersResultDeserializer;
impl DescribeEngineDefaultClusterParametersResultDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeEngineDefaultClusterParametersResult, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = DescribeEngineDefaultClusterParametersResult::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[..] {
"EngineDefaults" => {
obj.engine_defaults = Some(EngineDefaultsDeserializer::deserialize(
"EngineDefaults",
stack,
)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeEngineDefaultParametersMessage {
pub db_parameter_group_family: String,
pub filters: Option<Vec<Filter>>,
pub marker: Option<String>,
pub max_records: Option<i64>,
}
struct DescribeEngineDefaultParametersMessageSerializer;
impl DescribeEngineDefaultParametersMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeEngineDefaultParametersMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "DBParameterGroupFamily"),
&obj.db_parameter_group_family,
);
if let Some(ref field_value) = obj.filters {
FilterListSerializer::serialize(
params,
&format!("{}{}", prefix, "Filter"),
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 DescribeEngineDefaultParametersResult {
pub engine_defaults: Option<EngineDefaults>,
}
struct DescribeEngineDefaultParametersResultDeserializer;
impl DescribeEngineDefaultParametersResultDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeEngineDefaultParametersResult, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = DescribeEngineDefaultParametersResult::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[..] {
"EngineDefaults" => {
obj.engine_defaults = Some(EngineDefaultsDeserializer::deserialize(
"EngineDefaults",
stack,
)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeEventCategoriesMessage {
pub filters: Option<Vec<Filter>>,
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.filters {
FilterListSerializer::serialize(
params,
&format!("{}{}", prefix, "Filter"),
field_value,
);
}
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 filters: Option<Vec<Filter>>,
pub marker: Option<String>,
pub max_records: Option<i64>,
pub subscription_name: Option<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.filters {
FilterListSerializer::serialize(
params,
&format!("{}{}", prefix, "Filter"),
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.subscription_name {
params.put(&format!("{}{}", prefix, "SubscriptionName"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeEventsMessage {
pub duration: Option<i64>,
pub end_time: Option<String>,
pub event_categories: Option<Vec<String>>,
pub filters: Option<Vec<Filter>>,
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.event_categories {
EventCategoriesListSerializer::serialize(
params,
&format!("{}{}", prefix, "EventCategory"),
field_value,
);
}
if let Some(ref field_value) = obj.filters {
FilterListSerializer::serialize(
params,
&format!("{}{}", prefix, "Filter"),
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 DescribeOrderableDBInstanceOptionsMessage {
pub db_instance_class: Option<String>,
pub engine: String,
pub engine_version: Option<String>,
pub filters: Option<Vec<Filter>>,
pub license_model: Option<String>,
pub marker: Option<String>,
pub max_records: Option<i64>,
pub vpc: Option<bool>,
}
struct DescribeOrderableDBInstanceOptionsMessageSerializer;
impl DescribeOrderableDBInstanceOptionsMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeOrderableDBInstanceOptionsMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.db_instance_class {
params.put(&format!("{}{}", prefix, "DBInstanceClass"), &field_value);
}
params.put(&format!("{}{}", prefix, "Engine"), &obj.engine);
if let Some(ref field_value) = obj.engine_version {
params.put(&format!("{}{}", prefix, "EngineVersion"), &field_value);
}
if let Some(ref field_value) = obj.filters {
FilterListSerializer::serialize(
params,
&format!("{}{}", prefix, "Filter"),
field_value,
);
}
if let Some(ref field_value) = obj.license_model {
params.put(&format!("{}{}", prefix, "LicenseModel"), &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.vpc {
params.put(&format!("{}{}", prefix, "Vpc"), &field_value.to_string());
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribePendingMaintenanceActionsMessage {
pub filters: Option<Vec<Filter>>,
pub marker: Option<String>,
pub max_records: Option<i64>,
pub resource_identifier: Option<String>,
}
struct DescribePendingMaintenanceActionsMessageSerializer;
impl DescribePendingMaintenanceActionsMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribePendingMaintenanceActionsMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.filters {
FilterListSerializer::serialize(
params,
&format!("{}{}", prefix, "Filter"),
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.resource_identifier {
params.put(&format!("{}{}", prefix, "ResourceIdentifier"), &field_value);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeValidDBInstanceModificationsMessage {
pub db_instance_identifier: String,
}
struct DescribeValidDBInstanceModificationsMessageSerializer;
impl DescribeValidDBInstanceModificationsMessageSerializer {
fn serialize(
params: &mut Params,
name: &str,
obj: &DescribeValidDBInstanceModificationsMessage,
) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "DBInstanceIdentifier"),
&obj.db_instance_identifier,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DescribeValidDBInstanceModificationsResult {
pub valid_db_instance_modifications_message: Option<ValidDBInstanceModificationsMessage>,
}
struct DescribeValidDBInstanceModificationsResultDeserializer;
impl DescribeValidDBInstanceModificationsResultDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeValidDBInstanceModificationsResult, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = DescribeValidDBInstanceModificationsResult::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[..] {
"ValidDBInstanceModificationsMessage" => {
obj.valid_db_instance_modifications_message = Some(
ValidDBInstanceModificationsMessageDeserializer::deserialize(
"ValidDBInstanceModificationsMessage",
stack,
)?,
);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DomainMembership {
pub domain: Option<String>,
pub fqdn: Option<String>,
pub iam_role_name: Option<String>,
pub status: Option<String>,
}
struct DomainMembershipDeserializer;
impl DomainMembershipDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DomainMembership, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = DomainMembership::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[..] {
"Domain" => {
obj.domain = Some(StringDeserializer::deserialize("Domain", stack)?);
}
"FQDN" => {
obj.fqdn = Some(StringDeserializer::deserialize("FQDN", stack)?);
}
"IAMRoleName" => {
obj.iam_role_name =
Some(StringDeserializer::deserialize("IAMRoleName", stack)?);
}
"Status" => {
obj.status = Some(StringDeserializer::deserialize("Status", stack)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct DomainMembershipListDeserializer;
impl DomainMembershipListDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<DomainMembership>, XmlParseError> {
let mut obj = vec![];
start_element(tag_name, stack)?;
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "DomainMembership" {
obj.push(DomainMembershipDeserializer::deserialize(
"DomainMembership",
stack,
)?);
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
end_element(tag_name, stack)?;
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
struct DoubleDeserializer;
impl DoubleDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<f64, XmlParseError> {
start_element(tag_name, stack)?;
let obj = f64::from_str(characters(stack)?.as_ref()).unwrap();
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct DoubleOptionalDeserializer;
impl DoubleOptionalDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<f64, XmlParseError> {
start_element(tag_name, stack)?;
let obj = f64::from_str(characters(stack)?.as_ref()).unwrap();
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DoubleRange {
pub from: Option<f64>,
pub to: Option<f64>,
}
struct DoubleRangeDeserializer;
impl DoubleRangeDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DoubleRange, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = DoubleRange::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[..] {
"From" => {
obj.from = Some(DoubleDeserializer::deserialize("From", stack)?);
}
"To" => {
obj.to = Some(DoubleDeserializer::deserialize("To", stack)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct DoubleRangeListDeserializer;
impl DoubleRangeListDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<DoubleRange>, XmlParseError> {
let mut obj = vec![];
start_element(tag_name, stack)?;
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "DoubleRange" {
obj.push(DoubleRangeDeserializer::deserialize("DoubleRange", stack)?);
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
end_element(tag_name, stack)?;
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct Endpoint {
pub address: Option<String>,
pub hosted_zone_id: 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> {
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(StringDeserializer::deserialize("Address", stack)?);
}
"HostedZoneId" => {
obj.hosted_zone_id =
Some(StringDeserializer::deserialize("HostedZoneId", stack)?);
}
"Port" => {
obj.port = Some(IntegerDeserializer::deserialize("Port", stack)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct EngineDefaults {
pub db_parameter_group_family: Option<String>,
pub marker: Option<String>,
pub parameters: Option<Vec<Parameter>>,
}
struct EngineDefaultsDeserializer;
impl EngineDefaultsDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<EngineDefaults, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = EngineDefaults::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[..] {
"DBParameterGroupFamily" => {
obj.db_parameter_group_family = Some(StringDeserializer::deserialize(
"DBParameterGroupFamily",
stack,
)?);
}
"Marker" => {
obj.marker = Some(StringDeserializer::deserialize("Marker", stack)?);
}
"Parameters" => {
obj.parameters = match obj.parameters {
Some(ref mut existing) => {
existing.extend(ParametersListDeserializer::deserialize(
"Parameters",
stack,
)?);
Some(existing.to_vec())
}
None => Some(ParametersListDeserializer::deserialize(
"Parameters",
stack,
)?),
};
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct Event {
pub date: Option<String>,
pub event_categories: Option<Vec<String>>,
pub message: Option<String>,
pub source_arn: 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> {
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(TStampDeserializer::deserialize("Date", stack)?);
}
"EventCategories" => {
obj.event_categories = match obj.event_categories {
Some(ref mut existing) => {
existing.extend(EventCategoriesListDeserializer::deserialize(
"EventCategories",
stack,
)?);
Some(existing.to_vec())
}
None => Some(EventCategoriesListDeserializer::deserialize(
"EventCategories",
stack,
)?),
};
}
"Message" => {
obj.message = Some(StringDeserializer::deserialize("Message", stack)?);
}
"SourceArn" => {
obj.source_arn = Some(StringDeserializer::deserialize("SourceArn", stack)?);
}
"SourceIdentifier" => {
obj.source_identifier =
Some(StringDeserializer::deserialize("SourceIdentifier", stack)?);
}
"SourceType" => {
obj.source_type =
Some(SourceTypeDeserializer::deserialize("SourceType", stack)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
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![];
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(StringDeserializer::deserialize("EventCategory", stack)?);
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
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 event_categories: Option<Vec<String>>,
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> {
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[..] {
"EventCategories" => {
obj.event_categories = match obj.event_categories {
Some(ref mut existing) => {
existing.extend(EventCategoriesListDeserializer::deserialize(
"EventCategories",
stack,
)?);
Some(existing.to_vec())
}
None => Some(EventCategoriesListDeserializer::deserialize(
"EventCategories",
stack,
)?),
};
}
"SourceType" => {
obj.source_type =
Some(StringDeserializer::deserialize("SourceType", stack)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
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![];
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(EventCategoriesMapDeserializer::deserialize(
"EventCategoriesMap",
stack,
)?);
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
end_element(tag_name, stack)?;
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct 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> {
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(EventCategoriesMapListDeserializer::deserialize(
"EventCategoriesMapList",
stack,
)?);
Some(existing.to_vec())
}
None => Some(EventCategoriesMapListDeserializer::deserialize(
"EventCategoriesMapList",
stack,
)?),
};
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
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![];
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(EventDeserializer::deserialize("Event", stack)?);
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
end_element(tag_name, stack)?;
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct 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 event_subscription_arn: 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>,
}
struct EventSubscriptionDeserializer;
impl EventSubscriptionDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<EventSubscription, XmlParseError> {
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(StringDeserializer::deserialize(
"CustSubscriptionId",
stack,
)?);
}
"CustomerAwsId" => {
obj.customer_aws_id =
Some(StringDeserializer::deserialize("CustomerAwsId", stack)?);
}
"Enabled" => {
obj.enabled = Some(BooleanDeserializer::deserialize("Enabled", stack)?);
}
"EventCategoriesList" => {
obj.event_categories_list = match obj.event_categories_list {
Some(ref mut existing) => {
existing.extend(EventCategoriesListDeserializer::deserialize(
"EventCategoriesList",
stack,
)?);
Some(existing.to_vec())
}
None => Some(EventCategoriesListDeserializer::deserialize(
"EventCategoriesList",
stack,
)?),
};
}
"EventSubscriptionArn" => {
obj.event_subscription_arn = Some(StringDeserializer::deserialize(
"EventSubscriptionArn",
stack,
)?);
}
"SnsTopicArn" => {
obj.sns_topic_arn =
Some(StringDeserializer::deserialize("SnsTopicArn", stack)?);
}
"SourceIdsList" => {
obj.source_ids_list = match obj.source_ids_list {
Some(ref mut existing) => {
existing.extend(SourceIdsListDeserializer::deserialize(
"SourceIdsList",
stack,
)?);
Some(existing.to_vec())
}
None => Some(SourceIdsListDeserializer::deserialize(
"SourceIdsList",
stack,
)?),
};
}
"SourceType" => {
obj.source_type =
Some(StringDeserializer::deserialize("SourceType", stack)?);
}
"Status" => {
obj.status = Some(StringDeserializer::deserialize("Status", stack)?);
}
"SubscriptionCreationTime" => {
obj.subscription_creation_time = Some(StringDeserializer::deserialize(
"SubscriptionCreationTime",
stack,
)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
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![];
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(EventSubscriptionDeserializer::deserialize(
"EventSubscription",
stack,
)?);
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
end_element(tag_name, stack)?;
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct 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> {
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(EventSubscriptionsListDeserializer::deserialize(
"EventSubscriptionsList",
stack,
)?);
Some(existing.to_vec())
}
None => Some(EventSubscriptionsListDeserializer::deserialize(
"EventSubscriptionsList",
stack,
)?),
};
}
"Marker" => {
obj.marker = Some(StringDeserializer::deserialize("Marker", stack)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct 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> {
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(EventListDeserializer::deserialize("Events", stack)?);
Some(existing.to_vec())
}
None => Some(EventListDeserializer::deserialize("Events", stack)?),
};
}
"Marker" => {
obj.marker = Some(StringDeserializer::deserialize("Marker", stack)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct FailoverDBClusterMessage {
pub db_cluster_identifier: Option<String>,
pub target_db_instance_identifier: Option<String>,
}
struct FailoverDBClusterMessageSerializer;
impl FailoverDBClusterMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &FailoverDBClusterMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.db_cluster_identifier {
params.put(
&format!("{}{}", prefix, "DBClusterIdentifier"),
&field_value,
);
}
if let Some(ref field_value) = obj.target_db_instance_identifier {
params.put(
&format!("{}{}", prefix, "TargetDBInstanceIdentifier"),
&field_value,
);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct FailoverDBClusterResult {
pub db_cluster: Option<DBCluster>,
}
struct FailoverDBClusterResultDeserializer;
impl FailoverDBClusterResultDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<FailoverDBClusterResult, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = FailoverDBClusterResult::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[..] {
"DBCluster" => {
obj.db_cluster =
Some(DBClusterDeserializer::deserialize("DBCluster", stack)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct Filter {
pub name: String,
pub values: Vec<String>,
}
struct FilterSerializer;
impl FilterSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Filter) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(&format!("{}{}", prefix, "Name"), &obj.name);
FilterValueListSerializer::serialize(
params,
&format!("{}{}", prefix, "Value"),
&obj.values,
);
}
}
struct FilterListSerializer;
impl FilterListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<Filter>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.member.{}", name, index + 1);
FilterSerializer::serialize(params, &key, obj);
}
}
}
struct FilterValueListSerializer;
impl FilterValueListSerializer {
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 IntegerDeserializer;
impl IntegerDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<i64, XmlParseError> {
start_element(tag_name, stack)?;
let obj = i64::from_str(characters(stack)?.as_ref()).unwrap();
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct IntegerOptionalDeserializer;
impl IntegerOptionalDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<i64, XmlParseError> {
start_element(tag_name, stack)?;
let obj = i64::from_str(characters(stack)?.as_ref()).unwrap();
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct KeyListSerializer;
impl KeyListSerializer {
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 ListTagsForResourceMessage {
pub filters: Option<Vec<Filter>>,
pub resource_name: String,
}
struct ListTagsForResourceMessageSerializer;
impl ListTagsForResourceMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ListTagsForResourceMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.filters {
FilterListSerializer::serialize(
params,
&format!("{}{}", prefix, "Filter"),
field_value,
);
}
params.put(&format!("{}{}", prefix, "ResourceName"), &obj.resource_name);
}
}
struct LogTypeListDeserializer;
impl LogTypeListDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<String>, XmlParseError> {
let mut obj = vec![];
start_element(tag_name, stack)?;
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "member" {
obj.push(StringDeserializer::deserialize("member", stack)?);
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
end_element(tag_name, stack)?;
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
struct LogTypeListSerializer;
impl LogTypeListSerializer {
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 ModifyDBClusterMessage {
pub apply_immediately: Option<bool>,
pub backup_retention_period: Option<i64>,
pub db_cluster_identifier: String,
pub db_cluster_parameter_group_name: Option<String>,
pub enable_iam_database_authentication: Option<bool>,
pub engine_version: Option<String>,
pub master_user_password: Option<String>,
pub new_db_cluster_identifier: Option<String>,
pub option_group_name: Option<String>,
pub port: Option<i64>,
pub preferred_backup_window: Option<String>,
pub preferred_maintenance_window: Option<String>,
pub vpc_security_group_ids: Option<Vec<String>>,
}
struct ModifyDBClusterMessageSerializer;
impl ModifyDBClusterMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ModifyDBClusterMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.apply_immediately {
params.put(
&format!("{}{}", prefix, "ApplyImmediately"),
&field_value.to_string(),
);
}
if let Some(ref field_value) = obj.backup_retention_period {
params.put(
&format!("{}{}", prefix, "BackupRetentionPeriod"),
&field_value.to_string(),
);
}
params.put(
&format!("{}{}", prefix, "DBClusterIdentifier"),
&obj.db_cluster_identifier,
);
if let Some(ref field_value) = obj.db_cluster_parameter_group_name {
params.put(
&format!("{}{}", prefix, "DBClusterParameterGroupName"),
&field_value,
);
}
if let Some(ref field_value) = obj.enable_iam_database_authentication {
params.put(
&format!("{}{}", prefix, "EnableIAMDatabaseAuthentication"),
&field_value.to_string(),
);
}
if let Some(ref field_value) = obj.engine_version {
params.put(&format!("{}{}", prefix, "EngineVersion"), &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_db_cluster_identifier {
params.put(
&format!("{}{}", prefix, "NewDBClusterIdentifier"),
&field_value,
);
}
if let Some(ref field_value) = obj.option_group_name {
params.put(&format!("{}{}", prefix, "OptionGroupName"), &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_backup_window {
params.put(
&format!("{}{}", prefix, "PreferredBackupWindow"),
&field_value,
);
}
if let Some(ref field_value) = obj.preferred_maintenance_window {
params.put(
&format!("{}{}", prefix, "PreferredMaintenanceWindow"),
&field_value,
);
}
if let Some(ref field_value) = obj.vpc_security_group_ids {
VpcSecurityGroupIdListSerializer::serialize(
params,
&format!("{}{}", prefix, "VpcSecurityGroupId"),
field_value,
);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ModifyDBClusterParameterGroupMessage {
pub db_cluster_parameter_group_name: String,
pub parameters: Vec<Parameter>,
}
struct ModifyDBClusterParameterGroupMessageSerializer;
impl ModifyDBClusterParameterGroupMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ModifyDBClusterParameterGroupMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "DBClusterParameterGroupName"),
&obj.db_cluster_parameter_group_name,
);
ParametersListSerializer::serialize(
params,
&format!("{}{}", prefix, "Parameter"),
&obj.parameters,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ModifyDBClusterResult {
pub db_cluster: Option<DBCluster>,
}
struct ModifyDBClusterResultDeserializer;
impl ModifyDBClusterResultDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ModifyDBClusterResult, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = ModifyDBClusterResult::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[..] {
"DBCluster" => {
obj.db_cluster =
Some(DBClusterDeserializer::deserialize("DBCluster", stack)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ModifyDBClusterSnapshotAttributeMessage {
pub attribute_name: String,
pub db_cluster_snapshot_identifier: String,
pub values_to_add: Option<Vec<String>>,
pub values_to_remove: Option<Vec<String>>,
}
struct ModifyDBClusterSnapshotAttributeMessageSerializer;
impl ModifyDBClusterSnapshotAttributeMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ModifyDBClusterSnapshotAttributeMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "AttributeName"),
&obj.attribute_name,
);
params.put(
&format!("{}{}", prefix, "DBClusterSnapshotIdentifier"),
&obj.db_cluster_snapshot_identifier,
);
if let Some(ref field_value) = obj.values_to_add {
AttributeValueListSerializer::serialize(
params,
&format!("{}{}", prefix, "AttributeValue"),
field_value,
);
}
if let Some(ref field_value) = obj.values_to_remove {
AttributeValueListSerializer::serialize(
params,
&format!("{}{}", prefix, "AttributeValue"),
field_value,
);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ModifyDBClusterSnapshotAttributeResult {
pub db_cluster_snapshot_attributes_result: Option<DBClusterSnapshotAttributesResult>,
}
struct ModifyDBClusterSnapshotAttributeResultDeserializer;
impl ModifyDBClusterSnapshotAttributeResultDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ModifyDBClusterSnapshotAttributeResult, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = ModifyDBClusterSnapshotAttributeResult::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[..] {
"DBClusterSnapshotAttributesResult" => {
obj.db_cluster_snapshot_attributes_result =
Some(DBClusterSnapshotAttributesResultDeserializer::deserialize(
"DBClusterSnapshotAttributesResult",
stack,
)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ModifyDBInstanceMessage {
pub allocated_storage: Option<i64>,
pub allow_major_version_upgrade: Option<bool>,
pub apply_immediately: Option<bool>,
pub auto_minor_version_upgrade: Option<bool>,
pub backup_retention_period: Option<i64>,
pub ca_certificate_identifier: Option<String>,
pub cloudwatch_logs_export_configuration: Option<CloudwatchLogsExportConfiguration>,
pub copy_tags_to_snapshot: Option<bool>,
pub db_instance_class: Option<String>,
pub db_instance_identifier: String,
pub db_parameter_group_name: Option<String>,
pub db_port_number: Option<i64>,
pub db_security_groups: Option<Vec<String>>,
pub db_subnet_group_name: Option<String>,
pub domain: Option<String>,
pub domain_iam_role_name: Option<String>,
pub enable_iam_database_authentication: Option<bool>,
pub enable_performance_insights: Option<bool>,
pub engine_version: Option<String>,
pub iops: Option<i64>,
pub license_model: Option<String>,
pub master_user_password: Option<String>,
pub monitoring_interval: Option<i64>,
pub monitoring_role_arn: Option<String>,
pub multi_az: Option<bool>,
pub new_db_instance_identifier: Option<String>,
pub option_group_name: Option<String>,
pub performance_insights_kms_key_id: Option<String>,
pub preferred_backup_window: Option<String>,
pub preferred_maintenance_window: Option<String>,
pub promotion_tier: Option<i64>,
pub storage_type: Option<String>,
pub tde_credential_arn: Option<String>,
pub tde_credential_password: Option<String>,
pub vpc_security_group_ids: Option<Vec<String>>,
}
struct ModifyDBInstanceMessageSerializer;
impl ModifyDBInstanceMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ModifyDBInstanceMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.allocated_storage {
params.put(
&format!("{}{}", prefix, "AllocatedStorage"),
&field_value.to_string(),
);
}
if let Some(ref field_value) = obj.allow_major_version_upgrade {
params.put(
&format!("{}{}", prefix, "AllowMajorVersionUpgrade"),
&field_value.to_string(),
);
}
if let Some(ref field_value) = obj.apply_immediately {
params.put(
&format!("{}{}", prefix, "ApplyImmediately"),
&field_value.to_string(),
);
}
if let Some(ref field_value) = obj.auto_minor_version_upgrade {
params.put(
&format!("{}{}", prefix, "AutoMinorVersionUpgrade"),
&field_value.to_string(),
);
}
if let Some(ref field_value) = obj.backup_retention_period {
params.put(
&format!("{}{}", prefix, "BackupRetentionPeriod"),
&field_value.to_string(),
);
}
if let Some(ref field_value) = obj.ca_certificate_identifier {
params.put(
&format!("{}{}", prefix, "CACertificateIdentifier"),
&field_value,
);
}
if let Some(ref field_value) = obj.cloudwatch_logs_export_configuration {
CloudwatchLogsExportConfigurationSerializer::serialize(
params,
&format!("{}{}", prefix, "CloudwatchLogsExportConfiguration"),
field_value,
);
}
if let Some(ref field_value) = obj.copy_tags_to_snapshot {
params.put(
&format!("{}{}", prefix, "CopyTagsToSnapshot"),
&field_value.to_string(),
);
}
if let Some(ref field_value) = obj.db_instance_class {
params.put(&format!("{}{}", prefix, "DBInstanceClass"), &field_value);
}
params.put(
&format!("{}{}", prefix, "DBInstanceIdentifier"),
&obj.db_instance_identifier,
);
if let Some(ref field_value) = obj.db_parameter_group_name {
params.put(
&format!("{}{}", prefix, "DBParameterGroupName"),
&field_value,
);
}
if let Some(ref field_value) = obj.db_port_number {
params.put(
&format!("{}{}", prefix, "DBPortNumber"),
&field_value.to_string(),
);
}
if let Some(ref field_value) = obj.db_security_groups {
DBSecurityGroupNameListSerializer::serialize(
params,
&format!("{}{}", prefix, "DBSecurityGroupName"),
field_value,
);
}
if let Some(ref field_value) = obj.db_subnet_group_name {
params.put(&format!("{}{}", prefix, "DBSubnetGroupName"), &field_value);
}
if let Some(ref field_value) = obj.domain {
params.put(&format!("{}{}", prefix, "Domain"), &field_value);
}
if let Some(ref field_value) = obj.domain_iam_role_name {
params.put(&format!("{}{}", prefix, "DomainIAMRoleName"), &field_value);
}
if let Some(ref field_value) = obj.enable_iam_database_authentication {
params.put(
&format!("{}{}", prefix, "EnableIAMDatabaseAuthentication"),
&field_value.to_string(),
);
}
if let Some(ref field_value) = obj.enable_performance_insights {
params.put(
&format!("{}{}", prefix, "EnablePerformanceInsights"),
&field_value.to_string(),
);
}
if let Some(ref field_value) = obj.engine_version {
params.put(&format!("{}{}", prefix, "EngineVersion"), &field_value);
}
if let Some(ref field_value) = obj.iops {
params.put(&format!("{}{}", prefix, "Iops"), &field_value.to_string());
}
if let Some(ref field_value) = obj.license_model {
params.put(&format!("{}{}", prefix, "LicenseModel"), &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.monitoring_interval {
params.put(
&format!("{}{}", prefix, "MonitoringInterval"),
&field_value.to_string(),
);
}
if let Some(ref field_value) = obj.monitoring_role_arn {
params.put(&format!("{}{}", prefix, "MonitoringRoleArn"), &field_value);
}
if let Some(ref field_value) = obj.multi_az {
params.put(
&format!("{}{}", prefix, "MultiAZ"),
&field_value.to_string(),
);
}
if let Some(ref field_value) = obj.new_db_instance_identifier {
params.put(
&format!("{}{}", prefix, "NewDBInstanceIdentifier"),
&field_value,
);
}
if let Some(ref field_value) = obj.option_group_name {
params.put(&format!("{}{}", prefix, "OptionGroupName"), &field_value);
}
if let Some(ref field_value) = obj.performance_insights_kms_key_id {
params.put(
&format!("{}{}", prefix, "PerformanceInsightsKMSKeyId"),
&field_value,
);
}
if let Some(ref field_value) = obj.preferred_backup_window {
params.put(
&format!("{}{}", prefix, "PreferredBackupWindow"),
&field_value,
);
}
if let Some(ref field_value) = obj.preferred_maintenance_window {
params.put(
&format!("{}{}", prefix, "PreferredMaintenanceWindow"),
&field_value,
);
}
if let Some(ref field_value) = obj.promotion_tier {
params.put(
&format!("{}{}", prefix, "PromotionTier"),
&field_value.to_string(),
);
}
if let Some(ref field_value) = obj.storage_type {
params.put(&format!("{}{}", prefix, "StorageType"), &field_value);
}
if let Some(ref field_value) = obj.tde_credential_arn {
params.put(&format!("{}{}", prefix, "TdeCredentialArn"), &field_value);
}
if let Some(ref field_value) = obj.tde_credential_password {
params.put(
&format!("{}{}", prefix, "TdeCredentialPassword"),
&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 ModifyDBInstanceResult {
pub db_instance: Option<DBInstance>,
}
struct ModifyDBInstanceResultDeserializer;
impl ModifyDBInstanceResultDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ModifyDBInstanceResult, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = ModifyDBInstanceResult::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[..] {
"DBInstance" => {
obj.db_instance =
Some(DBInstanceDeserializer::deserialize("DBInstance", stack)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ModifyDBParameterGroupMessage {
pub db_parameter_group_name: String,
pub parameters: Vec<Parameter>,
}
struct ModifyDBParameterGroupMessageSerializer;
impl ModifyDBParameterGroupMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ModifyDBParameterGroupMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "DBParameterGroupName"),
&obj.db_parameter_group_name,
);
ParametersListSerializer::serialize(
params,
&format!("{}{}", prefix, "Parameter"),
&obj.parameters,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ModifyDBSubnetGroupMessage {
pub db_subnet_group_description: Option<String>,
pub db_subnet_group_name: String,
pub subnet_ids: Vec<String>,
}
struct ModifyDBSubnetGroupMessageSerializer;
impl ModifyDBSubnetGroupMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ModifyDBSubnetGroupMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.db_subnet_group_description {
params.put(
&format!("{}{}", prefix, "DBSubnetGroupDescription"),
&field_value,
);
}
params.put(
&format!("{}{}", prefix, "DBSubnetGroupName"),
&obj.db_subnet_group_name,
);
SubnetIdentifierListSerializer::serialize(
params,
&format!("{}{}", prefix, "SubnetIdentifier"),
&obj.subnet_ids,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ModifyDBSubnetGroupResult {
pub db_subnet_group: Option<DBSubnetGroup>,
}
struct ModifyDBSubnetGroupResultDeserializer;
impl ModifyDBSubnetGroupResultDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ModifyDBSubnetGroupResult, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = ModifyDBSubnetGroupResult::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[..] {
"DBSubnetGroup" => {
obj.db_subnet_group = Some(DBSubnetGroupDeserializer::deserialize(
"DBSubnetGroup",
stack,
)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ModifyEventSubscriptionMessage {
pub enabled: Option<bool>,
pub event_categories: Option<Vec<String>>,
pub sns_topic_arn: Option<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.sns_topic_arn {
params.put(&format!("{}{}", prefix, "SnsTopicArn"), &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> {
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(EventSubscriptionDeserializer::deserialize(
"EventSubscription",
stack,
)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct OptionGroupMembership {
pub option_group_name: Option<String>,
pub status: Option<String>,
}
struct OptionGroupMembershipDeserializer;
impl OptionGroupMembershipDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<OptionGroupMembership, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = OptionGroupMembership::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[..] {
"OptionGroupName" => {
obj.option_group_name =
Some(StringDeserializer::deserialize("OptionGroupName", stack)?);
}
"Status" => {
obj.status = Some(StringDeserializer::deserialize("Status", stack)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct OptionGroupMembershipListDeserializer;
impl OptionGroupMembershipListDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<OptionGroupMembership>, XmlParseError> {
let mut obj = vec![];
start_element(tag_name, stack)?;
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "OptionGroupMembership" {
obj.push(OptionGroupMembershipDeserializer::deserialize(
"OptionGroupMembership",
stack,
)?);
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
end_element(tag_name, stack)?;
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct OrderableDBInstanceOption {
pub availability_zones: Option<Vec<AvailabilityZone>>,
pub db_instance_class: Option<String>,
pub engine: Option<String>,
pub engine_version: Option<String>,
pub license_model: Option<String>,
pub max_iops_per_db_instance: Option<i64>,
pub max_iops_per_gib: Option<f64>,
pub max_storage_size: Option<i64>,
pub min_iops_per_db_instance: Option<i64>,
pub min_iops_per_gib: Option<f64>,
pub min_storage_size: Option<i64>,
pub multi_az_capable: Option<bool>,
pub read_replica_capable: Option<bool>,
pub storage_type: Option<String>,
pub supports_enhanced_monitoring: Option<bool>,
pub supports_iam_database_authentication: Option<bool>,
pub supports_iops: Option<bool>,
pub supports_performance_insights: Option<bool>,
pub supports_storage_encryption: Option<bool>,
pub vpc: Option<bool>,
}
struct OrderableDBInstanceOptionDeserializer;
impl OrderableDBInstanceOptionDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<OrderableDBInstanceOption, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = OrderableDBInstanceOption::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(AvailabilityZoneListDeserializer::deserialize(
"AvailabilityZones",
stack,
)?);
Some(existing.to_vec())
}
None => Some(AvailabilityZoneListDeserializer::deserialize(
"AvailabilityZones",
stack,
)?),
};
}
"DBInstanceClass" => {
obj.db_instance_class =
Some(StringDeserializer::deserialize("DBInstanceClass", stack)?);
}
"Engine" => {
obj.engine = Some(StringDeserializer::deserialize("Engine", stack)?);
}
"EngineVersion" => {
obj.engine_version =
Some(StringDeserializer::deserialize("EngineVersion", stack)?);
}
"LicenseModel" => {
obj.license_model =
Some(StringDeserializer::deserialize("LicenseModel", stack)?);
}
"MaxIopsPerDbInstance" => {
obj.max_iops_per_db_instance =
Some(IntegerOptionalDeserializer::deserialize(
"MaxIopsPerDbInstance",
stack,
)?);
}
"MaxIopsPerGib" => {
obj.max_iops_per_gib = Some(DoubleOptionalDeserializer::deserialize(
"MaxIopsPerGib",
stack,
)?);
}
"MaxStorageSize" => {
obj.max_storage_size = Some(IntegerOptionalDeserializer::deserialize(
"MaxStorageSize",
stack,
)?);
}
"MinIopsPerDbInstance" => {
obj.min_iops_per_db_instance =
Some(IntegerOptionalDeserializer::deserialize(
"MinIopsPerDbInstance",
stack,
)?);
}
"MinIopsPerGib" => {
obj.min_iops_per_gib = Some(DoubleOptionalDeserializer::deserialize(
"MinIopsPerGib",
stack,
)?);
}
"MinStorageSize" => {
obj.min_storage_size = Some(IntegerOptionalDeserializer::deserialize(
"MinStorageSize",
stack,
)?);
}
"MultiAZCapable" => {
obj.multi_az_capable =
Some(BooleanDeserializer::deserialize("MultiAZCapable", stack)?);
}
"ReadReplicaCapable" => {
obj.read_replica_capable = Some(BooleanDeserializer::deserialize(
"ReadReplicaCapable",
stack,
)?);
}
"StorageType" => {
obj.storage_type =
Some(StringDeserializer::deserialize("StorageType", stack)?);
}
"SupportsEnhancedMonitoring" => {
obj.supports_enhanced_monitoring = Some(BooleanDeserializer::deserialize(
"SupportsEnhancedMonitoring",
stack,
)?);
}
"SupportsIAMDatabaseAuthentication" => {
obj.supports_iam_database_authentication =
Some(BooleanDeserializer::deserialize(
"SupportsIAMDatabaseAuthentication",
stack,
)?);
}
"SupportsIops" => {
obj.supports_iops =
Some(BooleanDeserializer::deserialize("SupportsIops", stack)?);
}
"SupportsPerformanceInsights" => {
obj.supports_performance_insights = Some(BooleanDeserializer::deserialize(
"SupportsPerformanceInsights",
stack,
)?);
}
"SupportsStorageEncryption" => {
obj.supports_storage_encryption = Some(BooleanDeserializer::deserialize(
"SupportsStorageEncryption",
stack,
)?);
}
"Vpc" => {
obj.vpc = Some(BooleanDeserializer::deserialize("Vpc", stack)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct OrderableDBInstanceOptionsListDeserializer;
impl OrderableDBInstanceOptionsListDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<OrderableDBInstanceOption>, XmlParseError> {
let mut obj = vec![];
start_element(tag_name, stack)?;
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "OrderableDBInstanceOption" {
obj.push(OrderableDBInstanceOptionDeserializer::deserialize(
"OrderableDBInstanceOption",
stack,
)?);
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
end_element(tag_name, stack)?;
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct OrderableDBInstanceOptionsMessage {
pub marker: Option<String>,
pub orderable_db_instance_options: Option<Vec<OrderableDBInstanceOption>>,
}
struct OrderableDBInstanceOptionsMessageDeserializer;
impl OrderableDBInstanceOptionsMessageDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<OrderableDBInstanceOptionsMessage, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = OrderableDBInstanceOptionsMessage::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(StringDeserializer::deserialize("Marker", stack)?);
}
"OrderableDBInstanceOptions" => {
obj.orderable_db_instance_options = match obj.orderable_db_instance_options
{
Some(ref mut existing) => {
existing.extend(
OrderableDBInstanceOptionsListDeserializer::deserialize(
"OrderableDBInstanceOptions",
stack,
)?,
);
Some(existing.to_vec())
}
None => Some(OrderableDBInstanceOptionsListDeserializer::deserialize(
"OrderableDBInstanceOptions",
stack,
)?),
};
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct Parameter {
pub allowed_values: Option<String>,
pub apply_method: 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> {
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(StringDeserializer::deserialize("AllowedValues", stack)?);
}
"ApplyMethod" => {
obj.apply_method =
Some(ApplyMethodDeserializer::deserialize("ApplyMethod", stack)?);
}
"ApplyType" => {
obj.apply_type = Some(StringDeserializer::deserialize("ApplyType", stack)?);
}
"DataType" => {
obj.data_type = Some(StringDeserializer::deserialize("DataType", stack)?);
}
"Description" => {
obj.description =
Some(StringDeserializer::deserialize("Description", stack)?);
}
"IsModifiable" => {
obj.is_modifiable =
Some(BooleanDeserializer::deserialize("IsModifiable", stack)?);
}
"MinimumEngineVersion" => {
obj.minimum_engine_version = Some(StringDeserializer::deserialize(
"MinimumEngineVersion",
stack,
)?);
}
"ParameterName" => {
obj.parameter_name =
Some(StringDeserializer::deserialize("ParameterName", stack)?);
}
"ParameterValue" => {
obj.parameter_value =
Some(StringDeserializer::deserialize("ParameterValue", stack)?);
}
"Source" => {
obj.source = Some(StringDeserializer::deserialize("Source", stack)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
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_method {
params.put(&format!("{}{}", prefix, "ApplyMethod"), &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 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![];
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(ParameterDeserializer::deserialize("Parameter", stack)?);
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
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);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct PendingCloudwatchLogsExports {
pub log_types_to_disable: Option<Vec<String>>,
pub log_types_to_enable: Option<Vec<String>>,
}
struct PendingCloudwatchLogsExportsDeserializer;
impl PendingCloudwatchLogsExportsDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<PendingCloudwatchLogsExports, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = PendingCloudwatchLogsExports::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[..] {
"LogTypesToDisable" => {
obj.log_types_to_disable = match obj.log_types_to_disable {
Some(ref mut existing) => {
existing.extend(LogTypeListDeserializer::deserialize(
"LogTypesToDisable",
stack,
)?);
Some(existing.to_vec())
}
None => Some(LogTypeListDeserializer::deserialize(
"LogTypesToDisable",
stack,
)?),
};
}
"LogTypesToEnable" => {
obj.log_types_to_enable = match obj.log_types_to_enable {
Some(ref mut existing) => {
existing.extend(LogTypeListDeserializer::deserialize(
"LogTypesToEnable",
stack,
)?);
Some(existing.to_vec())
}
None => Some(LogTypeListDeserializer::deserialize(
"LogTypesToEnable",
stack,
)?),
};
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct PendingMaintenanceAction {
pub action: Option<String>,
pub auto_applied_after_date: Option<String>,
pub current_apply_date: Option<String>,
pub description: Option<String>,
pub forced_apply_date: Option<String>,
pub opt_in_status: Option<String>,
}
struct PendingMaintenanceActionDeserializer;
impl PendingMaintenanceActionDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<PendingMaintenanceAction, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = PendingMaintenanceAction::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[..] {
"Action" => {
obj.action = Some(StringDeserializer::deserialize("Action", stack)?);
}
"AutoAppliedAfterDate" => {
obj.auto_applied_after_date = Some(TStampDeserializer::deserialize(
"AutoAppliedAfterDate",
stack,
)?);
}
"CurrentApplyDate" => {
obj.current_apply_date =
Some(TStampDeserializer::deserialize("CurrentApplyDate", stack)?);
}
"Description" => {
obj.description =
Some(StringDeserializer::deserialize("Description", stack)?);
}
"ForcedApplyDate" => {
obj.forced_apply_date =
Some(TStampDeserializer::deserialize("ForcedApplyDate", stack)?);
}
"OptInStatus" => {
obj.opt_in_status =
Some(StringDeserializer::deserialize("OptInStatus", stack)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct PendingMaintenanceActionDetailsDeserializer;
impl PendingMaintenanceActionDetailsDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<PendingMaintenanceAction>, XmlParseError> {
let mut obj = vec![];
start_element(tag_name, stack)?;
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "PendingMaintenanceAction" {
obj.push(PendingMaintenanceActionDeserializer::deserialize(
"PendingMaintenanceAction",
stack,
)?);
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
end_element(tag_name, stack)?;
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
struct PendingMaintenanceActionsDeserializer;
impl PendingMaintenanceActionsDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<ResourcePendingMaintenanceActions>, XmlParseError> {
let mut obj = vec![];
start_element(tag_name, stack)?;
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "ResourcePendingMaintenanceActions" {
obj.push(ResourcePendingMaintenanceActionsDeserializer::deserialize(
"ResourcePendingMaintenanceActions",
stack,
)?);
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
end_element(tag_name, stack)?;
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct PendingMaintenanceActionsMessage {
pub marker: Option<String>,
pub pending_maintenance_actions: Option<Vec<ResourcePendingMaintenanceActions>>,
}
struct PendingMaintenanceActionsMessageDeserializer;
impl PendingMaintenanceActionsMessageDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<PendingMaintenanceActionsMessage, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = PendingMaintenanceActionsMessage::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(StringDeserializer::deserialize("Marker", stack)?);
}
"PendingMaintenanceActions" => {
obj.pending_maintenance_actions = match obj.pending_maintenance_actions {
Some(ref mut existing) => {
existing.extend(
PendingMaintenanceActionsDeserializer::deserialize(
"PendingMaintenanceActions",
stack,
)?,
);
Some(existing.to_vec())
}
None => Some(PendingMaintenanceActionsDeserializer::deserialize(
"PendingMaintenanceActions",
stack,
)?),
};
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct PendingModifiedValues {
pub allocated_storage: Option<i64>,
pub backup_retention_period: Option<i64>,
pub ca_certificate_identifier: Option<String>,
pub db_instance_class: Option<String>,
pub db_instance_identifier: Option<String>,
pub db_subnet_group_name: Option<String>,
pub engine_version: Option<String>,
pub iops: Option<i64>,
pub license_model: Option<String>,
pub master_user_password: Option<String>,
pub multi_az: Option<bool>,
pub pending_cloudwatch_logs_exports: Option<PendingCloudwatchLogsExports>,
pub port: Option<i64>,
pub storage_type: Option<String>,
}
struct PendingModifiedValuesDeserializer;
impl PendingModifiedValuesDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<PendingModifiedValues, XmlParseError> {
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[..] {
"AllocatedStorage" => {
obj.allocated_storage = Some(IntegerOptionalDeserializer::deserialize(
"AllocatedStorage",
stack,
)?);
}
"BackupRetentionPeriod" => {
obj.backup_retention_period =
Some(IntegerOptionalDeserializer::deserialize(
"BackupRetentionPeriod",
stack,
)?);
}
"CACertificateIdentifier" => {
obj.ca_certificate_identifier = Some(StringDeserializer::deserialize(
"CACertificateIdentifier",
stack,
)?);
}
"DBInstanceClass" => {
obj.db_instance_class =
Some(StringDeserializer::deserialize("DBInstanceClass", stack)?);
}
"DBInstanceIdentifier" => {
obj.db_instance_identifier = Some(StringDeserializer::deserialize(
"DBInstanceIdentifier",
stack,
)?);
}
"DBSubnetGroupName" => {
obj.db_subnet_group_name =
Some(StringDeserializer::deserialize("DBSubnetGroupName", stack)?);
}
"EngineVersion" => {
obj.engine_version =
Some(StringDeserializer::deserialize("EngineVersion", stack)?);
}
"Iops" => {
obj.iops = Some(IntegerOptionalDeserializer::deserialize("Iops", stack)?);
}
"LicenseModel" => {
obj.license_model =
Some(StringDeserializer::deserialize("LicenseModel", stack)?);
}
"MasterUserPassword" => {
obj.master_user_password = Some(StringDeserializer::deserialize(
"MasterUserPassword",
stack,
)?);
}
"MultiAZ" => {
obj.multi_az =
Some(BooleanOptionalDeserializer::deserialize("MultiAZ", stack)?);
}
"PendingCloudwatchLogsExports" => {
obj.pending_cloudwatch_logs_exports =
Some(PendingCloudwatchLogsExportsDeserializer::deserialize(
"PendingCloudwatchLogsExports",
stack,
)?);
}
"Port" => {
obj.port = Some(IntegerOptionalDeserializer::deserialize("Port", stack)?);
}
"StorageType" => {
obj.storage_type =
Some(StringDeserializer::deserialize("StorageType", stack)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct PromoteReadReplicaDBClusterMessage {
pub db_cluster_identifier: String,
}
struct PromoteReadReplicaDBClusterMessageSerializer;
impl PromoteReadReplicaDBClusterMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &PromoteReadReplicaDBClusterMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "DBClusterIdentifier"),
&obj.db_cluster_identifier,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct PromoteReadReplicaDBClusterResult {
pub db_cluster: Option<DBCluster>,
}
struct PromoteReadReplicaDBClusterResultDeserializer;
impl PromoteReadReplicaDBClusterResultDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<PromoteReadReplicaDBClusterResult, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = PromoteReadReplicaDBClusterResult::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[..] {
"DBCluster" => {
obj.db_cluster =
Some(DBClusterDeserializer::deserialize("DBCluster", stack)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct Range {
pub from: Option<i64>,
pub step: Option<i64>,
pub to: Option<i64>,
}
struct RangeDeserializer;
impl RangeDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Range, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = Range::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[..] {
"From" => {
obj.from = Some(IntegerDeserializer::deserialize("From", stack)?);
}
"Step" => {
obj.step = Some(IntegerOptionalDeserializer::deserialize("Step", stack)?);
}
"To" => {
obj.to = Some(IntegerDeserializer::deserialize("To", stack)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct RangeListDeserializer;
impl RangeListDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<Range>, XmlParseError> {
let mut obj = vec![];
start_element(tag_name, stack)?;
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "Range" {
obj.push(RangeDeserializer::deserialize("Range", stack)?);
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
end_element(tag_name, stack)?;
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
struct ReadReplicaDBClusterIdentifierListDeserializer;
impl ReadReplicaDBClusterIdentifierListDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<String>, XmlParseError> {
let mut obj = vec![];
start_element(tag_name, stack)?;
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "ReadReplicaDBClusterIdentifier" {
obj.push(StringDeserializer::deserialize(
"ReadReplicaDBClusterIdentifier",
stack,
)?);
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
end_element(tag_name, stack)?;
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
struct ReadReplicaDBInstanceIdentifierListDeserializer;
impl ReadReplicaDBInstanceIdentifierListDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<String>, XmlParseError> {
let mut obj = vec![];
start_element(tag_name, stack)?;
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "ReadReplicaDBInstanceIdentifier" {
obj.push(StringDeserializer::deserialize(
"ReadReplicaDBInstanceIdentifier",
stack,
)?);
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
end_element(tag_name, stack)?;
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
struct ReadReplicaIdentifierListDeserializer;
impl ReadReplicaIdentifierListDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<String>, XmlParseError> {
let mut obj = vec![];
start_element(tag_name, stack)?;
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "ReadReplicaIdentifier" {
obj.push(StringDeserializer::deserialize(
"ReadReplicaIdentifier",
stack,
)?);
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
end_element(tag_name, stack)?;
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct RebootDBInstanceMessage {
pub db_instance_identifier: String,
pub force_failover: Option<bool>,
}
struct RebootDBInstanceMessageSerializer;
impl RebootDBInstanceMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &RebootDBInstanceMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "DBInstanceIdentifier"),
&obj.db_instance_identifier,
);
if let Some(ref field_value) = obj.force_failover {
params.put(
&format!("{}{}", prefix, "ForceFailover"),
&field_value.to_string(),
);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct RebootDBInstanceResult {
pub db_instance: Option<DBInstance>,
}
struct RebootDBInstanceResultDeserializer;
impl RebootDBInstanceResultDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<RebootDBInstanceResult, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = RebootDBInstanceResult::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[..] {
"DBInstance" => {
obj.db_instance =
Some(DBInstanceDeserializer::deserialize("DBInstance", stack)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct RemoveRoleFromDBClusterMessage {
pub db_cluster_identifier: String,
pub role_arn: String,
}
struct RemoveRoleFromDBClusterMessageSerializer;
impl RemoveRoleFromDBClusterMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &RemoveRoleFromDBClusterMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "DBClusterIdentifier"),
&obj.db_cluster_identifier,
);
params.put(&format!("{}{}", prefix, "RoleArn"), &obj.role_arn);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct RemoveSourceIdentifierFromSubscriptionMessage {
pub source_identifier: String,
pub subscription_name: String,
}
struct RemoveSourceIdentifierFromSubscriptionMessageSerializer;
impl RemoveSourceIdentifierFromSubscriptionMessageSerializer {
fn serialize(
params: &mut Params,
name: &str,
obj: &RemoveSourceIdentifierFromSubscriptionMessage,
) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "SourceIdentifier"),
&obj.source_identifier,
);
params.put(
&format!("{}{}", prefix, "SubscriptionName"),
&obj.subscription_name,
);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct RemoveSourceIdentifierFromSubscriptionResult {
pub event_subscription: Option<EventSubscription>,
}
struct RemoveSourceIdentifierFromSubscriptionResultDeserializer;
impl RemoveSourceIdentifierFromSubscriptionResultDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<RemoveSourceIdentifierFromSubscriptionResult, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = RemoveSourceIdentifierFromSubscriptionResult::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(EventSubscriptionDeserializer::deserialize(
"EventSubscription",
stack,
)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct RemoveTagsFromResourceMessage {
pub resource_name: String,
pub tag_keys: Vec<String>,
}
struct RemoveTagsFromResourceMessageSerializer;
impl RemoveTagsFromResourceMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &RemoveTagsFromResourceMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(&format!("{}{}", prefix, "ResourceName"), &obj.resource_name);
KeyListSerializer::serialize(params, &format!("{}{}", prefix, "TagKeys"), &obj.tag_keys);
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ResetDBClusterParameterGroupMessage {
pub db_cluster_parameter_group_name: String,
pub parameters: Option<Vec<Parameter>>,
pub reset_all_parameters: Option<bool>,
}
struct ResetDBClusterParameterGroupMessageSerializer;
impl ResetDBClusterParameterGroupMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ResetDBClusterParameterGroupMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "DBClusterParameterGroupName"),
&obj.db_cluster_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 ResetDBParameterGroupMessage {
pub db_parameter_group_name: String,
pub parameters: Option<Vec<Parameter>>,
pub reset_all_parameters: Option<bool>,
}
struct ResetDBParameterGroupMessageSerializer;
impl ResetDBParameterGroupMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ResetDBParameterGroupMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "DBParameterGroupName"),
&obj.db_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 ResourcePendingMaintenanceActions {
pub pending_maintenance_action_details: Option<Vec<PendingMaintenanceAction>>,
pub resource_identifier: Option<String>,
}
struct ResourcePendingMaintenanceActionsDeserializer;
impl ResourcePendingMaintenanceActionsDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ResourcePendingMaintenanceActions, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = ResourcePendingMaintenanceActions::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[..] {
"PendingMaintenanceActionDetails" => {
obj.pending_maintenance_action_details = match obj
.pending_maintenance_action_details
{
Some(ref mut existing) => {
existing.extend(
PendingMaintenanceActionDetailsDeserializer::deserialize(
"PendingMaintenanceActionDetails",
stack,
)?,
);
Some(existing.to_vec())
}
None => Some(PendingMaintenanceActionDetailsDeserializer::deserialize(
"PendingMaintenanceActionDetails",
stack,
)?),
};
}
"ResourceIdentifier" => {
obj.resource_identifier = Some(StringDeserializer::deserialize(
"ResourceIdentifier",
stack,
)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct RestoreDBClusterFromSnapshotMessage {
pub availability_zones: Option<Vec<String>>,
pub db_cluster_identifier: String,
pub db_subnet_group_name: Option<String>,
pub database_name: Option<String>,
pub enable_iam_database_authentication: Option<bool>,
pub engine: String,
pub engine_version: Option<String>,
pub kms_key_id: Option<String>,
pub option_group_name: Option<String>,
pub port: Option<i64>,
pub snapshot_identifier: String,
pub tags: Option<Vec<Tag>>,
pub vpc_security_group_ids: Option<Vec<String>>,
}
struct RestoreDBClusterFromSnapshotMessageSerializer;
impl RestoreDBClusterFromSnapshotMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &RestoreDBClusterFromSnapshotMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.availability_zones {
AvailabilityZonesSerializer::serialize(
params,
&format!("{}{}", prefix, "AvailabilityZone"),
field_value,
);
}
params.put(
&format!("{}{}", prefix, "DBClusterIdentifier"),
&obj.db_cluster_identifier,
);
if let Some(ref field_value) = obj.db_subnet_group_name {
params.put(&format!("{}{}", prefix, "DBSubnetGroupName"), &field_value);
}
if let Some(ref field_value) = obj.database_name {
params.put(&format!("{}{}", prefix, "DatabaseName"), &field_value);
}
if let Some(ref field_value) = obj.enable_iam_database_authentication {
params.put(
&format!("{}{}", prefix, "EnableIAMDatabaseAuthentication"),
&field_value.to_string(),
);
}
params.put(&format!("{}{}", prefix, "Engine"), &obj.engine);
if let Some(ref field_value) = obj.engine_version {
params.put(&format!("{}{}", prefix, "EngineVersion"), &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.option_group_name {
params.put(&format!("{}{}", prefix, "OptionGroupName"), &field_value);
}
if let Some(ref field_value) = obj.port {
params.put(&format!("{}{}", prefix, "Port"), &field_value.to_string());
}
params.put(
&format!("{}{}", prefix, "SnapshotIdentifier"),
&obj.snapshot_identifier,
);
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 RestoreDBClusterFromSnapshotResult {
pub db_cluster: Option<DBCluster>,
}
struct RestoreDBClusterFromSnapshotResultDeserializer;
impl RestoreDBClusterFromSnapshotResultDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<RestoreDBClusterFromSnapshotResult, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = RestoreDBClusterFromSnapshotResult::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[..] {
"DBCluster" => {
obj.db_cluster =
Some(DBClusterDeserializer::deserialize("DBCluster", stack)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct RestoreDBClusterToPointInTimeMessage {
pub db_cluster_identifier: String,
pub db_subnet_group_name: Option<String>,
pub enable_iam_database_authentication: Option<bool>,
pub kms_key_id: Option<String>,
pub option_group_name: Option<String>,
pub port: Option<i64>,
pub restore_to_time: Option<String>,
pub restore_type: Option<String>,
pub source_db_cluster_identifier: String,
pub tags: Option<Vec<Tag>>,
pub use_latest_restorable_time: Option<bool>,
pub vpc_security_group_ids: Option<Vec<String>>,
}
struct RestoreDBClusterToPointInTimeMessageSerializer;
impl RestoreDBClusterToPointInTimeMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &RestoreDBClusterToPointInTimeMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "DBClusterIdentifier"),
&obj.db_cluster_identifier,
);
if let Some(ref field_value) = obj.db_subnet_group_name {
params.put(&format!("{}{}", prefix, "DBSubnetGroupName"), &field_value);
}
if let Some(ref field_value) = obj.enable_iam_database_authentication {
params.put(
&format!("{}{}", prefix, "EnableIAMDatabaseAuthentication"),
&field_value.to_string(),
);
}
if let Some(ref field_value) = obj.kms_key_id {
params.put(&format!("{}{}", prefix, "KmsKeyId"), &field_value);
}
if let Some(ref field_value) = obj.option_group_name {
params.put(&format!("{}{}", prefix, "OptionGroupName"), &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.restore_to_time {
params.put(&format!("{}{}", prefix, "RestoreToTime"), &field_value);
}
if let Some(ref field_value) = obj.restore_type {
params.put(&format!("{}{}", prefix, "RestoreType"), &field_value);
}
params.put(
&format!("{}{}", prefix, "SourceDBClusterIdentifier"),
&obj.source_db_cluster_identifier,
);
if let Some(ref field_value) = obj.tags {
TagListSerializer::serialize(params, &format!("{}{}", prefix, "Tag"), field_value);
}
if let Some(ref field_value) = obj.use_latest_restorable_time {
params.put(
&format!("{}{}", prefix, "UseLatestRestorableTime"),
&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 RestoreDBClusterToPointInTimeResult {
pub db_cluster: Option<DBCluster>,
}
struct RestoreDBClusterToPointInTimeResultDeserializer;
impl RestoreDBClusterToPointInTimeResultDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<RestoreDBClusterToPointInTimeResult, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = RestoreDBClusterToPointInTimeResult::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[..] {
"DBCluster" => {
obj.db_cluster =
Some(DBClusterDeserializer::deserialize("DBCluster", stack)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
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![];
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(StringDeserializer::deserialize("SourceId", stack)?);
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
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> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
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> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
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> {
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(AvailabilityZoneDeserializer::deserialize(
"SubnetAvailabilityZone",
stack,
)?);
}
"SubnetIdentifier" => {
obj.subnet_identifier =
Some(StringDeserializer::deserialize("SubnetIdentifier", stack)?);
}
"SubnetStatus" => {
obj.subnet_status =
Some(StringDeserializer::deserialize("SubnetStatus", stack)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
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![];
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(SubnetDeserializer::deserialize("Subnet", stack)?);
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
end_element(tag_name, stack)?;
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
struct SupportedCharacterSetsListDeserializer;
impl SupportedCharacterSetsListDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<CharacterSet>, XmlParseError> {
let mut obj = vec![];
start_element(tag_name, stack)?;
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "CharacterSet" {
obj.push(CharacterSetDeserializer::deserialize(
"CharacterSet",
stack,
)?);
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
end_element(tag_name, stack)?;
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
struct SupportedTimezonesListDeserializer;
impl SupportedTimezonesListDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<Timezone>, XmlParseError> {
let mut obj = vec![];
start_element(tag_name, stack)?;
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "Timezone" {
obj.push(TimezoneDeserializer::deserialize("Timezone", stack)?);
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
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> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
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> {
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(StringDeserializer::deserialize("Key", stack)?);
}
"Value" => {
obj.value = Some(StringDeserializer::deserialize("Value", stack)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
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 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![];
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(TagDeserializer::deserialize("Tag", stack)?);
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
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);
}
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct TagListMessage {
pub tag_list: Option<Vec<Tag>>,
}
struct TagListMessageDeserializer;
impl TagListMessageDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<TagListMessage, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = TagListMessage::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[..] {
"TagList" => {
obj.tag_list = match obj.tag_list {
Some(ref mut existing) => {
existing
.extend(TagListDeserializer::deserialize("TagList", stack)?);
Some(existing.to_vec())
}
None => Some(TagListDeserializer::deserialize("TagList", stack)?),
};
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct Timezone {
pub timezone_name: Option<String>,
}
struct TimezoneDeserializer;
impl TimezoneDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Timezone, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = Timezone::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[..] {
"TimezoneName" => {
obj.timezone_name =
Some(StringDeserializer::deserialize("TimezoneName", stack)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct UpgradeTarget {
pub auto_upgrade: Option<bool>,
pub description: Option<String>,
pub engine: Option<String>,
pub engine_version: Option<String>,
pub is_major_version_upgrade: Option<bool>,
}
struct UpgradeTargetDeserializer;
impl UpgradeTargetDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<UpgradeTarget, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = UpgradeTarget::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[..] {
"AutoUpgrade" => {
obj.auto_upgrade =
Some(BooleanDeserializer::deserialize("AutoUpgrade", stack)?);
}
"Description" => {
obj.description =
Some(StringDeserializer::deserialize("Description", stack)?);
}
"Engine" => {
obj.engine = Some(StringDeserializer::deserialize("Engine", stack)?);
}
"EngineVersion" => {
obj.engine_version =
Some(StringDeserializer::deserialize("EngineVersion", stack)?);
}
"IsMajorVersionUpgrade" => {
obj.is_major_version_upgrade = Some(BooleanDeserializer::deserialize(
"IsMajorVersionUpgrade",
stack,
)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ValidDBInstanceModificationsMessage {
pub storage: Option<Vec<ValidStorageOptions>>,
}
struct ValidDBInstanceModificationsMessageDeserializer;
impl ValidDBInstanceModificationsMessageDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ValidDBInstanceModificationsMessage, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = ValidDBInstanceModificationsMessage::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[..] {
"Storage" => {
obj.storage = match obj.storage {
Some(ref mut existing) => {
existing.extend(ValidStorageOptionsListDeserializer::deserialize(
"Storage", stack,
)?);
Some(existing.to_vec())
}
None => Some(ValidStorageOptionsListDeserializer::deserialize(
"Storage", stack,
)?),
};
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ValidStorageOptions {
pub iops_to_storage_ratio: Option<Vec<DoubleRange>>,
pub provisioned_iops: Option<Vec<Range>>,
pub storage_size: Option<Vec<Range>>,
pub storage_type: Option<String>,
}
struct ValidStorageOptionsDeserializer;
impl ValidStorageOptionsDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ValidStorageOptions, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = ValidStorageOptions::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[..] {
"IopsToStorageRatio" => {
obj.iops_to_storage_ratio = match obj.iops_to_storage_ratio {
Some(ref mut existing) => {
existing.extend(DoubleRangeListDeserializer::deserialize(
"IopsToStorageRatio",
stack,
)?);
Some(existing.to_vec())
}
None => Some(DoubleRangeListDeserializer::deserialize(
"IopsToStorageRatio",
stack,
)?),
};
}
"ProvisionedIops" => {
obj.provisioned_iops = match obj.provisioned_iops {
Some(ref mut existing) => {
existing.extend(RangeListDeserializer::deserialize(
"ProvisionedIops",
stack,
)?);
Some(existing.to_vec())
}
None => Some(RangeListDeserializer::deserialize(
"ProvisionedIops",
stack,
)?),
};
}
"StorageSize" => {
obj.storage_size = match obj.storage_size {
Some(ref mut existing) => {
existing.extend(RangeListDeserializer::deserialize(
"StorageSize",
stack,
)?);
Some(existing.to_vec())
}
None => Some(RangeListDeserializer::deserialize("StorageSize", stack)?),
};
}
"StorageType" => {
obj.storage_type =
Some(StringDeserializer::deserialize("StorageType", stack)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct ValidStorageOptionsListDeserializer;
impl ValidStorageOptionsListDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<ValidStorageOptions>, XmlParseError> {
let mut obj = vec![];
start_element(tag_name, stack)?;
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "ValidStorageOptions" {
obj.push(ValidStorageOptionsDeserializer::deserialize(
"ValidStorageOptions",
stack,
)?);
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
end_element(tag_name, stack)?;
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
struct ValidUpgradeTargetListDeserializer;
impl ValidUpgradeTargetListDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<UpgradeTarget>, XmlParseError> {
let mut obj = vec![];
start_element(tag_name, stack)?;
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "UpgradeTarget" {
obj.push(UpgradeTargetDeserializer::deserialize(
"UpgradeTarget",
stack,
)?);
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
end_element(tag_name, stack)?;
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
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> {
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(StringDeserializer::deserialize("Status", stack)?);
}
"VpcSecurityGroupId" => {
obj.vpc_security_group_id = Some(StringDeserializer::deserialize(
"VpcSecurityGroupId",
stack,
)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
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![];
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 == "VpcSecurityGroupMembership" {
obj.push(VpcSecurityGroupMembershipDeserializer::deserialize(
"VpcSecurityGroupMembership",
stack,
)?);
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
end_element(tag_name, stack)?;
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
#[derive(Debug, PartialEq)]
pub enum AddRoleToDBClusterError {
DBClusterNotFoundFault(String),
DBClusterRoleAlreadyExistsFault(String),
DBClusterRoleQuotaExceededFault(String),
InvalidDBClusterStateFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl AddRoleToDBClusterError {
pub fn from_response(res: BufferedHttpResponse) -> AddRoleToDBClusterError {
{
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[..] {
"DBClusterNotFoundFault" => {
return AddRoleToDBClusterError::DBClusterNotFoundFault(String::from(
parsed_error.message,
));
}
"DBClusterRoleAlreadyExists" => {
return AddRoleToDBClusterError::DBClusterRoleAlreadyExistsFault(
String::from(parsed_error.message),
);
}
"DBClusterRoleQuotaExceeded" => {
return AddRoleToDBClusterError::DBClusterRoleQuotaExceededFault(
String::from(parsed_error.message),
);
}
"InvalidDBClusterStateFault" => {
return AddRoleToDBClusterError::InvalidDBClusterStateFault(String::from(
parsed_error.message,
));
}
_ => {}
}
}
}
AddRoleToDBClusterError::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 AddRoleToDBClusterError {
fn from(err: XmlParseError) -> AddRoleToDBClusterError {
let XmlParseError(message) = err;
AddRoleToDBClusterError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for AddRoleToDBClusterError {
fn from(err: CredentialsError) -> AddRoleToDBClusterError {
AddRoleToDBClusterError::Credentials(err)
}
}
impl From<HttpDispatchError> for AddRoleToDBClusterError {
fn from(err: HttpDispatchError) -> AddRoleToDBClusterError {
AddRoleToDBClusterError::HttpDispatch(err)
}
}
impl From<io::Error> for AddRoleToDBClusterError {
fn from(err: io::Error) -> AddRoleToDBClusterError {
AddRoleToDBClusterError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for AddRoleToDBClusterError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for AddRoleToDBClusterError {
fn description(&self) -> &str {
match *self {
AddRoleToDBClusterError::DBClusterNotFoundFault(ref cause) => cause,
AddRoleToDBClusterError::DBClusterRoleAlreadyExistsFault(ref cause) => cause,
AddRoleToDBClusterError::DBClusterRoleQuotaExceededFault(ref cause) => cause,
AddRoleToDBClusterError::InvalidDBClusterStateFault(ref cause) => cause,
AddRoleToDBClusterError::Validation(ref cause) => cause,
AddRoleToDBClusterError::Credentials(ref err) => err.description(),
AddRoleToDBClusterError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
AddRoleToDBClusterError::ParseError(ref cause) => cause,
AddRoleToDBClusterError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum AddSourceIdentifierToSubscriptionError {
SourceNotFoundFault(String),
SubscriptionNotFoundFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl AddSourceIdentifierToSubscriptionError {
pub fn from_response(res: BufferedHttpResponse) -> AddSourceIdentifierToSubscriptionError {
{
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[..] {
"SourceNotFound" => {
return AddSourceIdentifierToSubscriptionError::SourceNotFoundFault(
String::from(parsed_error.message),
);
}
"SubscriptionNotFound" => {
return AddSourceIdentifierToSubscriptionError::SubscriptionNotFoundFault(
String::from(parsed_error.message),
);
}
_ => {}
}
}
}
AddSourceIdentifierToSubscriptionError::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 AddSourceIdentifierToSubscriptionError {
fn from(err: XmlParseError) -> AddSourceIdentifierToSubscriptionError {
let XmlParseError(message) = err;
AddSourceIdentifierToSubscriptionError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for AddSourceIdentifierToSubscriptionError {
fn from(err: CredentialsError) -> AddSourceIdentifierToSubscriptionError {
AddSourceIdentifierToSubscriptionError::Credentials(err)
}
}
impl From<HttpDispatchError> for AddSourceIdentifierToSubscriptionError {
fn from(err: HttpDispatchError) -> AddSourceIdentifierToSubscriptionError {
AddSourceIdentifierToSubscriptionError::HttpDispatch(err)
}
}
impl From<io::Error> for AddSourceIdentifierToSubscriptionError {
fn from(err: io::Error) -> AddSourceIdentifierToSubscriptionError {
AddSourceIdentifierToSubscriptionError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for AddSourceIdentifierToSubscriptionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for AddSourceIdentifierToSubscriptionError {
fn description(&self) -> &str {
match *self {
AddSourceIdentifierToSubscriptionError::SourceNotFoundFault(ref cause) => cause,
AddSourceIdentifierToSubscriptionError::SubscriptionNotFoundFault(ref cause) => cause,
AddSourceIdentifierToSubscriptionError::Validation(ref cause) => cause,
AddSourceIdentifierToSubscriptionError::Credentials(ref err) => err.description(),
AddSourceIdentifierToSubscriptionError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
AddSourceIdentifierToSubscriptionError::ParseError(ref cause) => cause,
AddSourceIdentifierToSubscriptionError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum AddTagsToResourceError {
DBClusterNotFoundFault(String),
DBInstanceNotFoundFault(String),
DBSnapshotNotFoundFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl AddTagsToResourceError {
pub fn from_response(res: BufferedHttpResponse) -> AddTagsToResourceError {
{
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[..] {
"DBClusterNotFoundFault" => {
return AddTagsToResourceError::DBClusterNotFoundFault(String::from(
parsed_error.message,
));
}
"DBInstanceNotFound" => {
return AddTagsToResourceError::DBInstanceNotFoundFault(String::from(
parsed_error.message,
));
}
"DBSnapshotNotFound" => {
return AddTagsToResourceError::DBSnapshotNotFoundFault(String::from(
parsed_error.message,
));
}
_ => {}
}
}
}
AddTagsToResourceError::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 AddTagsToResourceError {
fn from(err: XmlParseError) -> AddTagsToResourceError {
let XmlParseError(message) = err;
AddTagsToResourceError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for AddTagsToResourceError {
fn from(err: CredentialsError) -> AddTagsToResourceError {
AddTagsToResourceError::Credentials(err)
}
}
impl From<HttpDispatchError> for AddTagsToResourceError {
fn from(err: HttpDispatchError) -> AddTagsToResourceError {
AddTagsToResourceError::HttpDispatch(err)
}
}
impl From<io::Error> for AddTagsToResourceError {
fn from(err: io::Error) -> AddTagsToResourceError {
AddTagsToResourceError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for AddTagsToResourceError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for AddTagsToResourceError {
fn description(&self) -> &str {
match *self {
AddTagsToResourceError::DBClusterNotFoundFault(ref cause) => cause,
AddTagsToResourceError::DBInstanceNotFoundFault(ref cause) => cause,
AddTagsToResourceError::DBSnapshotNotFoundFault(ref cause) => cause,
AddTagsToResourceError::Validation(ref cause) => cause,
AddTagsToResourceError::Credentials(ref err) => err.description(),
AddTagsToResourceError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
AddTagsToResourceError::ParseError(ref cause) => cause,
AddTagsToResourceError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ApplyPendingMaintenanceActionError {
ResourceNotFoundFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ApplyPendingMaintenanceActionError {
pub fn from_response(res: BufferedHttpResponse) -> ApplyPendingMaintenanceActionError {
{
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[..] {
"ResourceNotFoundFault" => {
return ApplyPendingMaintenanceActionError::ResourceNotFoundFault(
String::from(parsed_error.message),
);
}
_ => {}
}
}
}
ApplyPendingMaintenanceActionError::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 ApplyPendingMaintenanceActionError {
fn from(err: XmlParseError) -> ApplyPendingMaintenanceActionError {
let XmlParseError(message) = err;
ApplyPendingMaintenanceActionError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for ApplyPendingMaintenanceActionError {
fn from(err: CredentialsError) -> ApplyPendingMaintenanceActionError {
ApplyPendingMaintenanceActionError::Credentials(err)
}
}
impl From<HttpDispatchError> for ApplyPendingMaintenanceActionError {
fn from(err: HttpDispatchError) -> ApplyPendingMaintenanceActionError {
ApplyPendingMaintenanceActionError::HttpDispatch(err)
}
}
impl From<io::Error> for ApplyPendingMaintenanceActionError {
fn from(err: io::Error) -> ApplyPendingMaintenanceActionError {
ApplyPendingMaintenanceActionError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ApplyPendingMaintenanceActionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ApplyPendingMaintenanceActionError {
fn description(&self) -> &str {
match *self {
ApplyPendingMaintenanceActionError::ResourceNotFoundFault(ref cause) => cause,
ApplyPendingMaintenanceActionError::Validation(ref cause) => cause,
ApplyPendingMaintenanceActionError::Credentials(ref err) => err.description(),
ApplyPendingMaintenanceActionError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
ApplyPendingMaintenanceActionError::ParseError(ref cause) => cause,
ApplyPendingMaintenanceActionError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum CopyDBClusterParameterGroupError {
DBParameterGroupAlreadyExistsFault(String),
DBParameterGroupNotFoundFault(String),
DBParameterGroupQuotaExceededFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CopyDBClusterParameterGroupError {
pub fn from_response(res: BufferedHttpResponse) -> CopyDBClusterParameterGroupError {
{
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[..] {
"DBParameterGroupAlreadyExists" => {
return CopyDBClusterParameterGroupError::DBParameterGroupAlreadyExistsFault(
String::from(parsed_error.message),
);
}
"DBParameterGroupNotFound" => {
return CopyDBClusterParameterGroupError::DBParameterGroupNotFoundFault(
String::from(parsed_error.message),
);
}
"DBParameterGroupQuotaExceeded" => {
return CopyDBClusterParameterGroupError::DBParameterGroupQuotaExceededFault(
String::from(parsed_error.message),
);
}
_ => {}
}
}
}
CopyDBClusterParameterGroupError::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 CopyDBClusterParameterGroupError {
fn from(err: XmlParseError) -> CopyDBClusterParameterGroupError {
let XmlParseError(message) = err;
CopyDBClusterParameterGroupError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for CopyDBClusterParameterGroupError {
fn from(err: CredentialsError) -> CopyDBClusterParameterGroupError {
CopyDBClusterParameterGroupError::Credentials(err)
}
}
impl From<HttpDispatchError> for CopyDBClusterParameterGroupError {
fn from(err: HttpDispatchError) -> CopyDBClusterParameterGroupError {
CopyDBClusterParameterGroupError::HttpDispatch(err)
}
}
impl From<io::Error> for CopyDBClusterParameterGroupError {
fn from(err: io::Error) -> CopyDBClusterParameterGroupError {
CopyDBClusterParameterGroupError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CopyDBClusterParameterGroupError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CopyDBClusterParameterGroupError {
fn description(&self) -> &str {
match *self {
CopyDBClusterParameterGroupError::DBParameterGroupAlreadyExistsFault(ref cause) => {
cause
}
CopyDBClusterParameterGroupError::DBParameterGroupNotFoundFault(ref cause) => cause,
CopyDBClusterParameterGroupError::DBParameterGroupQuotaExceededFault(ref cause) => {
cause
}
CopyDBClusterParameterGroupError::Validation(ref cause) => cause,
CopyDBClusterParameterGroupError::Credentials(ref err) => err.description(),
CopyDBClusterParameterGroupError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
CopyDBClusterParameterGroupError::ParseError(ref cause) => cause,
CopyDBClusterParameterGroupError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum CopyDBClusterSnapshotError {
DBClusterSnapshotAlreadyExistsFault(String),
DBClusterSnapshotNotFoundFault(String),
InvalidDBClusterSnapshotStateFault(String),
InvalidDBClusterStateFault(String),
KMSKeyNotAccessibleFault(String),
SnapshotQuotaExceededFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CopyDBClusterSnapshotError {
pub fn from_response(res: BufferedHttpResponse) -> CopyDBClusterSnapshotError {
{
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[..] {
"DBClusterSnapshotAlreadyExistsFault" => {
return CopyDBClusterSnapshotError::DBClusterSnapshotAlreadyExistsFault(
String::from(parsed_error.message),
);
}
"DBClusterSnapshotNotFoundFault" => {
return CopyDBClusterSnapshotError::DBClusterSnapshotNotFoundFault(
String::from(parsed_error.message),
);
}
"InvalidDBClusterSnapshotStateFault" => {
return CopyDBClusterSnapshotError::InvalidDBClusterSnapshotStateFault(
String::from(parsed_error.message),
);
}
"InvalidDBClusterStateFault" => {
return CopyDBClusterSnapshotError::InvalidDBClusterStateFault(String::from(
parsed_error.message,
));
}
"KMSKeyNotAccessibleFault" => {
return CopyDBClusterSnapshotError::KMSKeyNotAccessibleFault(String::from(
parsed_error.message,
));
}
"SnapshotQuotaExceeded" => {
return CopyDBClusterSnapshotError::SnapshotQuotaExceededFault(String::from(
parsed_error.message,
));
}
_ => {}
}
}
}
CopyDBClusterSnapshotError::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 CopyDBClusterSnapshotError {
fn from(err: XmlParseError) -> CopyDBClusterSnapshotError {
let XmlParseError(message) = err;
CopyDBClusterSnapshotError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for CopyDBClusterSnapshotError {
fn from(err: CredentialsError) -> CopyDBClusterSnapshotError {
CopyDBClusterSnapshotError::Credentials(err)
}
}
impl From<HttpDispatchError> for CopyDBClusterSnapshotError {
fn from(err: HttpDispatchError) -> CopyDBClusterSnapshotError {
CopyDBClusterSnapshotError::HttpDispatch(err)
}
}
impl From<io::Error> for CopyDBClusterSnapshotError {
fn from(err: io::Error) -> CopyDBClusterSnapshotError {
CopyDBClusterSnapshotError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CopyDBClusterSnapshotError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CopyDBClusterSnapshotError {
fn description(&self) -> &str {
match *self {
CopyDBClusterSnapshotError::DBClusterSnapshotAlreadyExistsFault(ref cause) => cause,
CopyDBClusterSnapshotError::DBClusterSnapshotNotFoundFault(ref cause) => cause,
CopyDBClusterSnapshotError::InvalidDBClusterSnapshotStateFault(ref cause) => cause,
CopyDBClusterSnapshotError::InvalidDBClusterStateFault(ref cause) => cause,
CopyDBClusterSnapshotError::KMSKeyNotAccessibleFault(ref cause) => cause,
CopyDBClusterSnapshotError::SnapshotQuotaExceededFault(ref cause) => cause,
CopyDBClusterSnapshotError::Validation(ref cause) => cause,
CopyDBClusterSnapshotError::Credentials(ref err) => err.description(),
CopyDBClusterSnapshotError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
CopyDBClusterSnapshotError::ParseError(ref cause) => cause,
CopyDBClusterSnapshotError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum CopyDBParameterGroupError {
DBParameterGroupAlreadyExistsFault(String),
DBParameterGroupNotFoundFault(String),
DBParameterGroupQuotaExceededFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CopyDBParameterGroupError {
pub fn from_response(res: BufferedHttpResponse) -> CopyDBParameterGroupError {
{
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[..] {
"DBParameterGroupAlreadyExists" => {
return CopyDBParameterGroupError::DBParameterGroupAlreadyExistsFault(
String::from(parsed_error.message),
);
}
"DBParameterGroupNotFound" => {
return CopyDBParameterGroupError::DBParameterGroupNotFoundFault(
String::from(parsed_error.message),
);
}
"DBParameterGroupQuotaExceeded" => {
return CopyDBParameterGroupError::DBParameterGroupQuotaExceededFault(
String::from(parsed_error.message),
);
}
_ => {}
}
}
}
CopyDBParameterGroupError::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 CopyDBParameterGroupError {
fn from(err: XmlParseError) -> CopyDBParameterGroupError {
let XmlParseError(message) = err;
CopyDBParameterGroupError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for CopyDBParameterGroupError {
fn from(err: CredentialsError) -> CopyDBParameterGroupError {
CopyDBParameterGroupError::Credentials(err)
}
}
impl From<HttpDispatchError> for CopyDBParameterGroupError {
fn from(err: HttpDispatchError) -> CopyDBParameterGroupError {
CopyDBParameterGroupError::HttpDispatch(err)
}
}
impl From<io::Error> for CopyDBParameterGroupError {
fn from(err: io::Error) -> CopyDBParameterGroupError {
CopyDBParameterGroupError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CopyDBParameterGroupError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CopyDBParameterGroupError {
fn description(&self) -> &str {
match *self {
CopyDBParameterGroupError::DBParameterGroupAlreadyExistsFault(ref cause) => cause,
CopyDBParameterGroupError::DBParameterGroupNotFoundFault(ref cause) => cause,
CopyDBParameterGroupError::DBParameterGroupQuotaExceededFault(ref cause) => cause,
CopyDBParameterGroupError::Validation(ref cause) => cause,
CopyDBParameterGroupError::Credentials(ref err) => err.description(),
CopyDBParameterGroupError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
CopyDBParameterGroupError::ParseError(ref cause) => cause,
CopyDBParameterGroupError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateDBClusterError {
DBClusterAlreadyExistsFault(String),
DBClusterNotFoundFault(String),
DBClusterParameterGroupNotFoundFault(String),
DBClusterQuotaExceededFault(String),
DBInstanceNotFoundFault(String),
DBSubnetGroupDoesNotCoverEnoughAZs(String),
DBSubnetGroupNotFoundFault(String),
InsufficientStorageClusterCapacityFault(String),
InvalidDBClusterStateFault(String),
InvalidDBInstanceStateFault(String),
InvalidDBSubnetGroupStateFault(String),
InvalidSubnet(String),
InvalidVPCNetworkStateFault(String),
KMSKeyNotAccessibleFault(String),
StorageQuotaExceededFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CreateDBClusterError {
pub fn from_response(res: BufferedHttpResponse) -> CreateDBClusterError {
{
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[..] {
"DBClusterAlreadyExistsFault" => {
return CreateDBClusterError::DBClusterAlreadyExistsFault(String::from(
parsed_error.message,
));
}
"DBClusterNotFoundFault" => {
return CreateDBClusterError::DBClusterNotFoundFault(String::from(
parsed_error.message,
));
}
"DBClusterParameterGroupNotFound" => {
return CreateDBClusterError::DBClusterParameterGroupNotFoundFault(
String::from(parsed_error.message),
);
}
"DBClusterQuotaExceededFault" => {
return CreateDBClusterError::DBClusterQuotaExceededFault(String::from(
parsed_error.message,
));
}
"DBInstanceNotFound" => {
return CreateDBClusterError::DBInstanceNotFoundFault(String::from(
parsed_error.message,
));
}
"DBSubnetGroupDoesNotCoverEnoughAZs" => {
return CreateDBClusterError::DBSubnetGroupDoesNotCoverEnoughAZs(
String::from(parsed_error.message),
);
}
"DBSubnetGroupNotFoundFault" => {
return CreateDBClusterError::DBSubnetGroupNotFoundFault(String::from(
parsed_error.message,
));
}
"InsufficientStorageClusterCapacity" => {
return CreateDBClusterError::InsufficientStorageClusterCapacityFault(
String::from(parsed_error.message),
);
}
"InvalidDBClusterStateFault" => {
return CreateDBClusterError::InvalidDBClusterStateFault(String::from(
parsed_error.message,
));
}
"InvalidDBInstanceState" => {
return CreateDBClusterError::InvalidDBInstanceStateFault(String::from(
parsed_error.message,
));
}
"InvalidDBSubnetGroupStateFault" => {
return CreateDBClusterError::InvalidDBSubnetGroupStateFault(String::from(
parsed_error.message,
));
}
"InvalidSubnet" => {
return CreateDBClusterError::InvalidSubnet(String::from(
parsed_error.message,
));
}
"InvalidVPCNetworkStateFault" => {
return CreateDBClusterError::InvalidVPCNetworkStateFault(String::from(
parsed_error.message,
));
}
"KMSKeyNotAccessibleFault" => {
return CreateDBClusterError::KMSKeyNotAccessibleFault(String::from(
parsed_error.message,
));
}
"StorageQuotaExceeded" => {
return CreateDBClusterError::StorageQuotaExceededFault(String::from(
parsed_error.message,
));
}
_ => {}
}
}
}
CreateDBClusterError::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 CreateDBClusterError {
fn from(err: XmlParseError) -> CreateDBClusterError {
let XmlParseError(message) = err;
CreateDBClusterError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for CreateDBClusterError {
fn from(err: CredentialsError) -> CreateDBClusterError {
CreateDBClusterError::Credentials(err)
}
}
impl From<HttpDispatchError> for CreateDBClusterError {
fn from(err: HttpDispatchError) -> CreateDBClusterError {
CreateDBClusterError::HttpDispatch(err)
}
}
impl From<io::Error> for CreateDBClusterError {
fn from(err: io::Error) -> CreateDBClusterError {
CreateDBClusterError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CreateDBClusterError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateDBClusterError {
fn description(&self) -> &str {
match *self {
CreateDBClusterError::DBClusterAlreadyExistsFault(ref cause) => cause,
CreateDBClusterError::DBClusterNotFoundFault(ref cause) => cause,
CreateDBClusterError::DBClusterParameterGroupNotFoundFault(ref cause) => cause,
CreateDBClusterError::DBClusterQuotaExceededFault(ref cause) => cause,
CreateDBClusterError::DBInstanceNotFoundFault(ref cause) => cause,
CreateDBClusterError::DBSubnetGroupDoesNotCoverEnoughAZs(ref cause) => cause,
CreateDBClusterError::DBSubnetGroupNotFoundFault(ref cause) => cause,
CreateDBClusterError::InsufficientStorageClusterCapacityFault(ref cause) => cause,
CreateDBClusterError::InvalidDBClusterStateFault(ref cause) => cause,
CreateDBClusterError::InvalidDBInstanceStateFault(ref cause) => cause,
CreateDBClusterError::InvalidDBSubnetGroupStateFault(ref cause) => cause,
CreateDBClusterError::InvalidSubnet(ref cause) => cause,
CreateDBClusterError::InvalidVPCNetworkStateFault(ref cause) => cause,
CreateDBClusterError::KMSKeyNotAccessibleFault(ref cause) => cause,
CreateDBClusterError::StorageQuotaExceededFault(ref cause) => cause,
CreateDBClusterError::Validation(ref cause) => cause,
CreateDBClusterError::Credentials(ref err) => err.description(),
CreateDBClusterError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
CreateDBClusterError::ParseError(ref cause) => cause,
CreateDBClusterError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateDBClusterParameterGroupError {
DBParameterGroupAlreadyExistsFault(String),
DBParameterGroupQuotaExceededFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CreateDBClusterParameterGroupError {
pub fn from_response(res: BufferedHttpResponse) -> CreateDBClusterParameterGroupError {
{
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[..] {
"DBParameterGroupAlreadyExists" => return CreateDBClusterParameterGroupError::DBParameterGroupAlreadyExistsFault(String::from(parsed_error.message)),"DBParameterGroupQuotaExceeded" => return CreateDBClusterParameterGroupError::DBParameterGroupQuotaExceededFault(String::from(parsed_error.message)),_ => {}
}
}
}
CreateDBClusterParameterGroupError::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 CreateDBClusterParameterGroupError {
fn from(err: XmlParseError) -> CreateDBClusterParameterGroupError {
let XmlParseError(message) = err;
CreateDBClusterParameterGroupError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for CreateDBClusterParameterGroupError {
fn from(err: CredentialsError) -> CreateDBClusterParameterGroupError {
CreateDBClusterParameterGroupError::Credentials(err)
}
}
impl From<HttpDispatchError> for CreateDBClusterParameterGroupError {
fn from(err: HttpDispatchError) -> CreateDBClusterParameterGroupError {
CreateDBClusterParameterGroupError::HttpDispatch(err)
}
}
impl From<io::Error> for CreateDBClusterParameterGroupError {
fn from(err: io::Error) -> CreateDBClusterParameterGroupError {
CreateDBClusterParameterGroupError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CreateDBClusterParameterGroupError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateDBClusterParameterGroupError {
fn description(&self) -> &str {
match *self {
CreateDBClusterParameterGroupError::DBParameterGroupAlreadyExistsFault(ref cause) => {
cause
}
CreateDBClusterParameterGroupError::DBParameterGroupQuotaExceededFault(ref cause) => {
cause
}
CreateDBClusterParameterGroupError::Validation(ref cause) => cause,
CreateDBClusterParameterGroupError::Credentials(ref err) => err.description(),
CreateDBClusterParameterGroupError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
CreateDBClusterParameterGroupError::ParseError(ref cause) => cause,
CreateDBClusterParameterGroupError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateDBClusterSnapshotError {
DBClusterNotFoundFault(String),
DBClusterSnapshotAlreadyExistsFault(String),
InvalidDBClusterSnapshotStateFault(String),
InvalidDBClusterStateFault(String),
SnapshotQuotaExceededFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CreateDBClusterSnapshotError {
pub fn from_response(res: BufferedHttpResponse) -> CreateDBClusterSnapshotError {
{
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[..] {
"DBClusterNotFoundFault" => {
return CreateDBClusterSnapshotError::DBClusterNotFoundFault(String::from(
parsed_error.message,
));
}
"DBClusterSnapshotAlreadyExistsFault" => {
return CreateDBClusterSnapshotError::DBClusterSnapshotAlreadyExistsFault(
String::from(parsed_error.message),
);
}
"InvalidDBClusterSnapshotStateFault" => {
return CreateDBClusterSnapshotError::InvalidDBClusterSnapshotStateFault(
String::from(parsed_error.message),
);
}
"InvalidDBClusterStateFault" => {
return CreateDBClusterSnapshotError::InvalidDBClusterStateFault(
String::from(parsed_error.message),
);
}
"SnapshotQuotaExceeded" => {
return CreateDBClusterSnapshotError::SnapshotQuotaExceededFault(
String::from(parsed_error.message),
);
}
_ => {}
}
}
}
CreateDBClusterSnapshotError::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 CreateDBClusterSnapshotError {
fn from(err: XmlParseError) -> CreateDBClusterSnapshotError {
let XmlParseError(message) = err;
CreateDBClusterSnapshotError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for CreateDBClusterSnapshotError {
fn from(err: CredentialsError) -> CreateDBClusterSnapshotError {
CreateDBClusterSnapshotError::Credentials(err)
}
}
impl From<HttpDispatchError> for CreateDBClusterSnapshotError {
fn from(err: HttpDispatchError) -> CreateDBClusterSnapshotError {
CreateDBClusterSnapshotError::HttpDispatch(err)
}
}
impl From<io::Error> for CreateDBClusterSnapshotError {
fn from(err: io::Error) -> CreateDBClusterSnapshotError {
CreateDBClusterSnapshotError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CreateDBClusterSnapshotError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateDBClusterSnapshotError {
fn description(&self) -> &str {
match *self {
CreateDBClusterSnapshotError::DBClusterNotFoundFault(ref cause) => cause,
CreateDBClusterSnapshotError::DBClusterSnapshotAlreadyExistsFault(ref cause) => cause,
CreateDBClusterSnapshotError::InvalidDBClusterSnapshotStateFault(ref cause) => cause,
CreateDBClusterSnapshotError::InvalidDBClusterStateFault(ref cause) => cause,
CreateDBClusterSnapshotError::SnapshotQuotaExceededFault(ref cause) => cause,
CreateDBClusterSnapshotError::Validation(ref cause) => cause,
CreateDBClusterSnapshotError::Credentials(ref err) => err.description(),
CreateDBClusterSnapshotError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
CreateDBClusterSnapshotError::ParseError(ref cause) => cause,
CreateDBClusterSnapshotError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateDBInstanceError {
AuthorizationNotFoundFault(String),
DBClusterNotFoundFault(String),
DBInstanceAlreadyExistsFault(String),
DBParameterGroupNotFoundFault(String),
DBSecurityGroupNotFoundFault(String),
DBSubnetGroupDoesNotCoverEnoughAZs(String),
DBSubnetGroupNotFoundFault(String),
DomainNotFoundFault(String),
InstanceQuotaExceededFault(String),
InsufficientDBInstanceCapacityFault(String),
InvalidDBClusterStateFault(String),
InvalidSubnet(String),
InvalidVPCNetworkStateFault(String),
KMSKeyNotAccessibleFault(String),
OptionGroupNotFoundFault(String),
ProvisionedIopsNotAvailableInAZFault(String),
StorageQuotaExceededFault(String),
StorageTypeNotSupportedFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CreateDBInstanceError {
pub fn from_response(res: BufferedHttpResponse) -> CreateDBInstanceError {
{
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 CreateDBInstanceError::AuthorizationNotFoundFault(String::from(
parsed_error.message,
));
}
"DBClusterNotFoundFault" => {
return CreateDBInstanceError::DBClusterNotFoundFault(String::from(
parsed_error.message,
));
}
"DBInstanceAlreadyExists" => {
return CreateDBInstanceError::DBInstanceAlreadyExistsFault(String::from(
parsed_error.message,
));
}
"DBParameterGroupNotFound" => {
return CreateDBInstanceError::DBParameterGroupNotFoundFault(String::from(
parsed_error.message,
));
}
"DBSecurityGroupNotFound" => {
return CreateDBInstanceError::DBSecurityGroupNotFoundFault(String::from(
parsed_error.message,
));
}
"DBSubnetGroupDoesNotCoverEnoughAZs" => {
return CreateDBInstanceError::DBSubnetGroupDoesNotCoverEnoughAZs(
String::from(parsed_error.message),
);
}
"DBSubnetGroupNotFoundFault" => {
return CreateDBInstanceError::DBSubnetGroupNotFoundFault(String::from(
parsed_error.message,
));
}
"DomainNotFoundFault" => {
return CreateDBInstanceError::DomainNotFoundFault(String::from(
parsed_error.message,
));
}
"InstanceQuotaExceeded" => {
return CreateDBInstanceError::InstanceQuotaExceededFault(String::from(
parsed_error.message,
));
}
"InsufficientDBInstanceCapacity" => {
return CreateDBInstanceError::InsufficientDBInstanceCapacityFault(
String::from(parsed_error.message),
);
}
"InvalidDBClusterStateFault" => {
return CreateDBInstanceError::InvalidDBClusterStateFault(String::from(
parsed_error.message,
));
}
"InvalidSubnet" => {
return CreateDBInstanceError::InvalidSubnet(String::from(
parsed_error.message,
));
}
"InvalidVPCNetworkStateFault" => {
return CreateDBInstanceError::InvalidVPCNetworkStateFault(String::from(
parsed_error.message,
));
}
"KMSKeyNotAccessibleFault" => {
return CreateDBInstanceError::KMSKeyNotAccessibleFault(String::from(
parsed_error.message,
));
}
"OptionGroupNotFoundFault" => {
return CreateDBInstanceError::OptionGroupNotFoundFault(String::from(
parsed_error.message,
));
}
"ProvisionedIopsNotAvailableInAZFault" => {
return CreateDBInstanceError::ProvisionedIopsNotAvailableInAZFault(
String::from(parsed_error.message),
);
}
"StorageQuotaExceeded" => {
return CreateDBInstanceError::StorageQuotaExceededFault(String::from(
parsed_error.message,
));
}
"StorageTypeNotSupported" => {
return CreateDBInstanceError::StorageTypeNotSupportedFault(String::from(
parsed_error.message,
));
}
_ => {}
}
}
}
CreateDBInstanceError::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 CreateDBInstanceError {
fn from(err: XmlParseError) -> CreateDBInstanceError {
let XmlParseError(message) = err;
CreateDBInstanceError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for CreateDBInstanceError {
fn from(err: CredentialsError) -> CreateDBInstanceError {
CreateDBInstanceError::Credentials(err)
}
}
impl From<HttpDispatchError> for CreateDBInstanceError {
fn from(err: HttpDispatchError) -> CreateDBInstanceError {
CreateDBInstanceError::HttpDispatch(err)
}
}
impl From<io::Error> for CreateDBInstanceError {
fn from(err: io::Error) -> CreateDBInstanceError {
CreateDBInstanceError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CreateDBInstanceError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateDBInstanceError {
fn description(&self) -> &str {
match *self {
CreateDBInstanceError::AuthorizationNotFoundFault(ref cause) => cause,
CreateDBInstanceError::DBClusterNotFoundFault(ref cause) => cause,
CreateDBInstanceError::DBInstanceAlreadyExistsFault(ref cause) => cause,
CreateDBInstanceError::DBParameterGroupNotFoundFault(ref cause) => cause,
CreateDBInstanceError::DBSecurityGroupNotFoundFault(ref cause) => cause,
CreateDBInstanceError::DBSubnetGroupDoesNotCoverEnoughAZs(ref cause) => cause,
CreateDBInstanceError::DBSubnetGroupNotFoundFault(ref cause) => cause,
CreateDBInstanceError::DomainNotFoundFault(ref cause) => cause,
CreateDBInstanceError::InstanceQuotaExceededFault(ref cause) => cause,
CreateDBInstanceError::InsufficientDBInstanceCapacityFault(ref cause) => cause,
CreateDBInstanceError::InvalidDBClusterStateFault(ref cause) => cause,
CreateDBInstanceError::InvalidSubnet(ref cause) => cause,
CreateDBInstanceError::InvalidVPCNetworkStateFault(ref cause) => cause,
CreateDBInstanceError::KMSKeyNotAccessibleFault(ref cause) => cause,
CreateDBInstanceError::OptionGroupNotFoundFault(ref cause) => cause,
CreateDBInstanceError::ProvisionedIopsNotAvailableInAZFault(ref cause) => cause,
CreateDBInstanceError::StorageQuotaExceededFault(ref cause) => cause,
CreateDBInstanceError::StorageTypeNotSupportedFault(ref cause) => cause,
CreateDBInstanceError::Validation(ref cause) => cause,
CreateDBInstanceError::Credentials(ref err) => err.description(),
CreateDBInstanceError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
CreateDBInstanceError::ParseError(ref cause) => cause,
CreateDBInstanceError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateDBParameterGroupError {
DBParameterGroupAlreadyExistsFault(String),
DBParameterGroupQuotaExceededFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CreateDBParameterGroupError {
pub fn from_response(res: BufferedHttpResponse) -> CreateDBParameterGroupError {
{
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[..] {
"DBParameterGroupAlreadyExists" => {
return CreateDBParameterGroupError::DBParameterGroupAlreadyExistsFault(
String::from(parsed_error.message),
);
}
"DBParameterGroupQuotaExceeded" => {
return CreateDBParameterGroupError::DBParameterGroupQuotaExceededFault(
String::from(parsed_error.message),
);
}
_ => {}
}
}
}
CreateDBParameterGroupError::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 CreateDBParameterGroupError {
fn from(err: XmlParseError) -> CreateDBParameterGroupError {
let XmlParseError(message) = err;
CreateDBParameterGroupError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for CreateDBParameterGroupError {
fn from(err: CredentialsError) -> CreateDBParameterGroupError {
CreateDBParameterGroupError::Credentials(err)
}
}
impl From<HttpDispatchError> for CreateDBParameterGroupError {
fn from(err: HttpDispatchError) -> CreateDBParameterGroupError {
CreateDBParameterGroupError::HttpDispatch(err)
}
}
impl From<io::Error> for CreateDBParameterGroupError {
fn from(err: io::Error) -> CreateDBParameterGroupError {
CreateDBParameterGroupError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CreateDBParameterGroupError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateDBParameterGroupError {
fn description(&self) -> &str {
match *self {
CreateDBParameterGroupError::DBParameterGroupAlreadyExistsFault(ref cause) => cause,
CreateDBParameterGroupError::DBParameterGroupQuotaExceededFault(ref cause) => cause,
CreateDBParameterGroupError::Validation(ref cause) => cause,
CreateDBParameterGroupError::Credentials(ref err) => err.description(),
CreateDBParameterGroupError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
CreateDBParameterGroupError::ParseError(ref cause) => cause,
CreateDBParameterGroupError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateDBSubnetGroupError {
DBSubnetGroupAlreadyExistsFault(String),
DBSubnetGroupDoesNotCoverEnoughAZs(String),
DBSubnetGroupQuotaExceededFault(String),
DBSubnetQuotaExceededFault(String),
InvalidSubnet(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CreateDBSubnetGroupError {
pub fn from_response(res: BufferedHttpResponse) -> CreateDBSubnetGroupError {
{
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[..] {
"DBSubnetGroupAlreadyExists" => {
return CreateDBSubnetGroupError::DBSubnetGroupAlreadyExistsFault(
String::from(parsed_error.message),
);
}
"DBSubnetGroupDoesNotCoverEnoughAZs" => {
return CreateDBSubnetGroupError::DBSubnetGroupDoesNotCoverEnoughAZs(
String::from(parsed_error.message),
);
}
"DBSubnetGroupQuotaExceeded" => {
return CreateDBSubnetGroupError::DBSubnetGroupQuotaExceededFault(
String::from(parsed_error.message),
);
}
"DBSubnetQuotaExceededFault" => {
return CreateDBSubnetGroupError::DBSubnetQuotaExceededFault(String::from(
parsed_error.message,
));
}
"InvalidSubnet" => {
return CreateDBSubnetGroupError::InvalidSubnet(String::from(
parsed_error.message,
));
}
_ => {}
}
}
}
CreateDBSubnetGroupError::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 CreateDBSubnetGroupError {
fn from(err: XmlParseError) -> CreateDBSubnetGroupError {
let XmlParseError(message) = err;
CreateDBSubnetGroupError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for CreateDBSubnetGroupError {
fn from(err: CredentialsError) -> CreateDBSubnetGroupError {
CreateDBSubnetGroupError::Credentials(err)
}
}
impl From<HttpDispatchError> for CreateDBSubnetGroupError {
fn from(err: HttpDispatchError) -> CreateDBSubnetGroupError {
CreateDBSubnetGroupError::HttpDispatch(err)
}
}
impl From<io::Error> for CreateDBSubnetGroupError {
fn from(err: io::Error) -> CreateDBSubnetGroupError {
CreateDBSubnetGroupError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CreateDBSubnetGroupError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateDBSubnetGroupError {
fn description(&self) -> &str {
match *self {
CreateDBSubnetGroupError::DBSubnetGroupAlreadyExistsFault(ref cause) => cause,
CreateDBSubnetGroupError::DBSubnetGroupDoesNotCoverEnoughAZs(ref cause) => cause,
CreateDBSubnetGroupError::DBSubnetGroupQuotaExceededFault(ref cause) => cause,
CreateDBSubnetGroupError::DBSubnetQuotaExceededFault(ref cause) => cause,
CreateDBSubnetGroupError::InvalidSubnet(ref cause) => cause,
CreateDBSubnetGroupError::Validation(ref cause) => cause,
CreateDBSubnetGroupError::Credentials(ref err) => err.description(),
CreateDBSubnetGroupError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
CreateDBSubnetGroupError::ParseError(ref cause) => cause,
CreateDBSubnetGroupError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateEventSubscriptionError {
EventSubscriptionQuotaExceededFault(String),
SNSInvalidTopicFault(String),
SNSNoAuthorizationFault(String),
SNSTopicArnNotFoundFault(String),
SourceNotFoundFault(String),
SubscriptionAlreadyExistFault(String),
SubscriptionCategoryNotFoundFault(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),
);
}
"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),
);
}
_ => {}
}
}
}
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::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::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 DeleteDBClusterError {
DBClusterNotFoundFault(String),
DBClusterSnapshotAlreadyExistsFault(String),
InvalidDBClusterSnapshotStateFault(String),
InvalidDBClusterStateFault(String),
SnapshotQuotaExceededFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DeleteDBClusterError {
pub fn from_response(res: BufferedHttpResponse) -> DeleteDBClusterError {
{
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[..] {
"DBClusterNotFoundFault" => {
return DeleteDBClusterError::DBClusterNotFoundFault(String::from(
parsed_error.message,
));
}
"DBClusterSnapshotAlreadyExistsFault" => {
return DeleteDBClusterError::DBClusterSnapshotAlreadyExistsFault(
String::from(parsed_error.message),
);
}
"InvalidDBClusterSnapshotStateFault" => {
return DeleteDBClusterError::InvalidDBClusterSnapshotStateFault(
String::from(parsed_error.message),
);
}
"InvalidDBClusterStateFault" => {
return DeleteDBClusterError::InvalidDBClusterStateFault(String::from(
parsed_error.message,
));
}
"SnapshotQuotaExceeded" => {
return DeleteDBClusterError::SnapshotQuotaExceededFault(String::from(
parsed_error.message,
));
}
_ => {}
}
}
}
DeleteDBClusterError::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 DeleteDBClusterError {
fn from(err: XmlParseError) -> DeleteDBClusterError {
let XmlParseError(message) = err;
DeleteDBClusterError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DeleteDBClusterError {
fn from(err: CredentialsError) -> DeleteDBClusterError {
DeleteDBClusterError::Credentials(err)
}
}
impl From<HttpDispatchError> for DeleteDBClusterError {
fn from(err: HttpDispatchError) -> DeleteDBClusterError {
DeleteDBClusterError::HttpDispatch(err)
}
}
impl From<io::Error> for DeleteDBClusterError {
fn from(err: io::Error) -> DeleteDBClusterError {
DeleteDBClusterError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DeleteDBClusterError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteDBClusterError {
fn description(&self) -> &str {
match *self {
DeleteDBClusterError::DBClusterNotFoundFault(ref cause) => cause,
DeleteDBClusterError::DBClusterSnapshotAlreadyExistsFault(ref cause) => cause,
DeleteDBClusterError::InvalidDBClusterSnapshotStateFault(ref cause) => cause,
DeleteDBClusterError::InvalidDBClusterStateFault(ref cause) => cause,
DeleteDBClusterError::SnapshotQuotaExceededFault(ref cause) => cause,
DeleteDBClusterError::Validation(ref cause) => cause,
DeleteDBClusterError::Credentials(ref err) => err.description(),
DeleteDBClusterError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
DeleteDBClusterError::ParseError(ref cause) => cause,
DeleteDBClusterError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteDBClusterParameterGroupError {
DBParameterGroupNotFoundFault(String),
InvalidDBParameterGroupStateFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DeleteDBClusterParameterGroupError {
pub fn from_response(res: BufferedHttpResponse) -> DeleteDBClusterParameterGroupError {
{
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[..] {
"DBParameterGroupNotFound" => {
return DeleteDBClusterParameterGroupError::DBParameterGroupNotFoundFault(
String::from(parsed_error.message),
);
}
"InvalidDBParameterGroupState" => {
return DeleteDBClusterParameterGroupError::InvalidDBParameterGroupStateFault(
String::from(parsed_error.message),
);
}
_ => {}
}
}
}
DeleteDBClusterParameterGroupError::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 DeleteDBClusterParameterGroupError {
fn from(err: XmlParseError) -> DeleteDBClusterParameterGroupError {
let XmlParseError(message) = err;
DeleteDBClusterParameterGroupError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DeleteDBClusterParameterGroupError {
fn from(err: CredentialsError) -> DeleteDBClusterParameterGroupError {
DeleteDBClusterParameterGroupError::Credentials(err)
}
}
impl From<HttpDispatchError> for DeleteDBClusterParameterGroupError {
fn from(err: HttpDispatchError) -> DeleteDBClusterParameterGroupError {
DeleteDBClusterParameterGroupError::HttpDispatch(err)
}
}
impl From<io::Error> for DeleteDBClusterParameterGroupError {
fn from(err: io::Error) -> DeleteDBClusterParameterGroupError {
DeleteDBClusterParameterGroupError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DeleteDBClusterParameterGroupError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteDBClusterParameterGroupError {
fn description(&self) -> &str {
match *self {
DeleteDBClusterParameterGroupError::DBParameterGroupNotFoundFault(ref cause) => cause,
DeleteDBClusterParameterGroupError::InvalidDBParameterGroupStateFault(ref cause) => {
cause
}
DeleteDBClusterParameterGroupError::Validation(ref cause) => cause,
DeleteDBClusterParameterGroupError::Credentials(ref err) => err.description(),
DeleteDBClusterParameterGroupError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DeleteDBClusterParameterGroupError::ParseError(ref cause) => cause,
DeleteDBClusterParameterGroupError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteDBClusterSnapshotError {
DBClusterSnapshotNotFoundFault(String),
InvalidDBClusterSnapshotStateFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DeleteDBClusterSnapshotError {
pub fn from_response(res: BufferedHttpResponse) -> DeleteDBClusterSnapshotError {
{
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[..] {
"DBClusterSnapshotNotFoundFault" => {
return DeleteDBClusterSnapshotError::DBClusterSnapshotNotFoundFault(
String::from(parsed_error.message),
);
}
"InvalidDBClusterSnapshotStateFault" => {
return DeleteDBClusterSnapshotError::InvalidDBClusterSnapshotStateFault(
String::from(parsed_error.message),
);
}
_ => {}
}
}
}
DeleteDBClusterSnapshotError::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 DeleteDBClusterSnapshotError {
fn from(err: XmlParseError) -> DeleteDBClusterSnapshotError {
let XmlParseError(message) = err;
DeleteDBClusterSnapshotError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DeleteDBClusterSnapshotError {
fn from(err: CredentialsError) -> DeleteDBClusterSnapshotError {
DeleteDBClusterSnapshotError::Credentials(err)
}
}
impl From<HttpDispatchError> for DeleteDBClusterSnapshotError {
fn from(err: HttpDispatchError) -> DeleteDBClusterSnapshotError {
DeleteDBClusterSnapshotError::HttpDispatch(err)
}
}
impl From<io::Error> for DeleteDBClusterSnapshotError {
fn from(err: io::Error) -> DeleteDBClusterSnapshotError {
DeleteDBClusterSnapshotError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DeleteDBClusterSnapshotError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteDBClusterSnapshotError {
fn description(&self) -> &str {
match *self {
DeleteDBClusterSnapshotError::DBClusterSnapshotNotFoundFault(ref cause) => cause,
DeleteDBClusterSnapshotError::InvalidDBClusterSnapshotStateFault(ref cause) => cause,
DeleteDBClusterSnapshotError::Validation(ref cause) => cause,
DeleteDBClusterSnapshotError::Credentials(ref err) => err.description(),
DeleteDBClusterSnapshotError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DeleteDBClusterSnapshotError::ParseError(ref cause) => cause,
DeleteDBClusterSnapshotError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteDBInstanceError {
DBInstanceNotFoundFault(String),
DBSnapshotAlreadyExistsFault(String),
InvalidDBClusterStateFault(String),
InvalidDBInstanceStateFault(String),
SnapshotQuotaExceededFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DeleteDBInstanceError {
pub fn from_response(res: BufferedHttpResponse) -> DeleteDBInstanceError {
{
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[..] {
"DBInstanceNotFound" => {
return DeleteDBInstanceError::DBInstanceNotFoundFault(String::from(
parsed_error.message,
));
}
"DBSnapshotAlreadyExists" => {
return DeleteDBInstanceError::DBSnapshotAlreadyExistsFault(String::from(
parsed_error.message,
));
}
"InvalidDBClusterStateFault" => {
return DeleteDBInstanceError::InvalidDBClusterStateFault(String::from(
parsed_error.message,
));
}
"InvalidDBInstanceState" => {
return DeleteDBInstanceError::InvalidDBInstanceStateFault(String::from(
parsed_error.message,
));
}
"SnapshotQuotaExceeded" => {
return DeleteDBInstanceError::SnapshotQuotaExceededFault(String::from(
parsed_error.message,
));
}
_ => {}
}
}
}
DeleteDBInstanceError::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 DeleteDBInstanceError {
fn from(err: XmlParseError) -> DeleteDBInstanceError {
let XmlParseError(message) = err;
DeleteDBInstanceError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DeleteDBInstanceError {
fn from(err: CredentialsError) -> DeleteDBInstanceError {
DeleteDBInstanceError::Credentials(err)
}
}
impl From<HttpDispatchError> for DeleteDBInstanceError {
fn from(err: HttpDispatchError) -> DeleteDBInstanceError {
DeleteDBInstanceError::HttpDispatch(err)
}
}
impl From<io::Error> for DeleteDBInstanceError {
fn from(err: io::Error) -> DeleteDBInstanceError {
DeleteDBInstanceError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DeleteDBInstanceError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteDBInstanceError {
fn description(&self) -> &str {
match *self {
DeleteDBInstanceError::DBInstanceNotFoundFault(ref cause) => cause,
DeleteDBInstanceError::DBSnapshotAlreadyExistsFault(ref cause) => cause,
DeleteDBInstanceError::InvalidDBClusterStateFault(ref cause) => cause,
DeleteDBInstanceError::InvalidDBInstanceStateFault(ref cause) => cause,
DeleteDBInstanceError::SnapshotQuotaExceededFault(ref cause) => cause,
DeleteDBInstanceError::Validation(ref cause) => cause,
DeleteDBInstanceError::Credentials(ref err) => err.description(),
DeleteDBInstanceError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
DeleteDBInstanceError::ParseError(ref cause) => cause,
DeleteDBInstanceError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteDBParameterGroupError {
DBParameterGroupNotFoundFault(String),
InvalidDBParameterGroupStateFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DeleteDBParameterGroupError {
pub fn from_response(res: BufferedHttpResponse) -> DeleteDBParameterGroupError {
{
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[..] {
"DBParameterGroupNotFound" => {
return DeleteDBParameterGroupError::DBParameterGroupNotFoundFault(
String::from(parsed_error.message),
);
}
"InvalidDBParameterGroupState" => {
return DeleteDBParameterGroupError::InvalidDBParameterGroupStateFault(
String::from(parsed_error.message),
);
}
_ => {}
}
}
}
DeleteDBParameterGroupError::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 DeleteDBParameterGroupError {
fn from(err: XmlParseError) -> DeleteDBParameterGroupError {
let XmlParseError(message) = err;
DeleteDBParameterGroupError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DeleteDBParameterGroupError {
fn from(err: CredentialsError) -> DeleteDBParameterGroupError {
DeleteDBParameterGroupError::Credentials(err)
}
}
impl From<HttpDispatchError> for DeleteDBParameterGroupError {
fn from(err: HttpDispatchError) -> DeleteDBParameterGroupError {
DeleteDBParameterGroupError::HttpDispatch(err)
}
}
impl From<io::Error> for DeleteDBParameterGroupError {
fn from(err: io::Error) -> DeleteDBParameterGroupError {
DeleteDBParameterGroupError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DeleteDBParameterGroupError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteDBParameterGroupError {
fn description(&self) -> &str {
match *self {
DeleteDBParameterGroupError::DBParameterGroupNotFoundFault(ref cause) => cause,
DeleteDBParameterGroupError::InvalidDBParameterGroupStateFault(ref cause) => cause,
DeleteDBParameterGroupError::Validation(ref cause) => cause,
DeleteDBParameterGroupError::Credentials(ref err) => err.description(),
DeleteDBParameterGroupError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DeleteDBParameterGroupError::ParseError(ref cause) => cause,
DeleteDBParameterGroupError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteDBSubnetGroupError {
DBSubnetGroupNotFoundFault(String),
InvalidDBSubnetGroupStateFault(String),
InvalidDBSubnetStateFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DeleteDBSubnetGroupError {
pub fn from_response(res: BufferedHttpResponse) -> DeleteDBSubnetGroupError {
{
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[..] {
"DBSubnetGroupNotFoundFault" => {
return DeleteDBSubnetGroupError::DBSubnetGroupNotFoundFault(String::from(
parsed_error.message,
));
}
"InvalidDBSubnetGroupStateFault" => {
return DeleteDBSubnetGroupError::InvalidDBSubnetGroupStateFault(
String::from(parsed_error.message),
);
}
"InvalidDBSubnetStateFault" => {
return DeleteDBSubnetGroupError::InvalidDBSubnetStateFault(String::from(
parsed_error.message,
));
}
_ => {}
}
}
}
DeleteDBSubnetGroupError::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 DeleteDBSubnetGroupError {
fn from(err: XmlParseError) -> DeleteDBSubnetGroupError {
let XmlParseError(message) = err;
DeleteDBSubnetGroupError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DeleteDBSubnetGroupError {
fn from(err: CredentialsError) -> DeleteDBSubnetGroupError {
DeleteDBSubnetGroupError::Credentials(err)
}
}
impl From<HttpDispatchError> for DeleteDBSubnetGroupError {
fn from(err: HttpDispatchError) -> DeleteDBSubnetGroupError {
DeleteDBSubnetGroupError::HttpDispatch(err)
}
}
impl From<io::Error> for DeleteDBSubnetGroupError {
fn from(err: io::Error) -> DeleteDBSubnetGroupError {
DeleteDBSubnetGroupError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DeleteDBSubnetGroupError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteDBSubnetGroupError {
fn description(&self) -> &str {
match *self {
DeleteDBSubnetGroupError::DBSubnetGroupNotFoundFault(ref cause) => cause,
DeleteDBSubnetGroupError::InvalidDBSubnetGroupStateFault(ref cause) => cause,
DeleteDBSubnetGroupError::InvalidDBSubnetStateFault(ref cause) => cause,
DeleteDBSubnetGroupError::Validation(ref cause) => cause,
DeleteDBSubnetGroupError::Credentials(ref err) => err.description(),
DeleteDBSubnetGroupError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DeleteDBSubnetGroupError::ParseError(ref cause) => cause,
DeleteDBSubnetGroupError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteEventSubscriptionError {
InvalidEventSubscriptionStateFault(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[..] {
"InvalidEventSubscriptionState" => {
return DeleteEventSubscriptionError::InvalidEventSubscriptionStateFault(
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::InvalidEventSubscriptionStateFault(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 DescribeDBClusterParameterGroupsError {
DBParameterGroupNotFoundFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeDBClusterParameterGroupsError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeDBClusterParameterGroupsError {
{
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[..] {
"DBParameterGroupNotFound" => {
return DescribeDBClusterParameterGroupsError::DBParameterGroupNotFoundFault(
String::from(parsed_error.message),
);
}
_ => {}
}
}
}
DescribeDBClusterParameterGroupsError::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 DescribeDBClusterParameterGroupsError {
fn from(err: XmlParseError) -> DescribeDBClusterParameterGroupsError {
let XmlParseError(message) = err;
DescribeDBClusterParameterGroupsError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DescribeDBClusterParameterGroupsError {
fn from(err: CredentialsError) -> DescribeDBClusterParameterGroupsError {
DescribeDBClusterParameterGroupsError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeDBClusterParameterGroupsError {
fn from(err: HttpDispatchError) -> DescribeDBClusterParameterGroupsError {
DescribeDBClusterParameterGroupsError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeDBClusterParameterGroupsError {
fn from(err: io::Error) -> DescribeDBClusterParameterGroupsError {
DescribeDBClusterParameterGroupsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeDBClusterParameterGroupsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeDBClusterParameterGroupsError {
fn description(&self) -> &str {
match *self {
DescribeDBClusterParameterGroupsError::DBParameterGroupNotFoundFault(ref cause) => {
cause
}
DescribeDBClusterParameterGroupsError::Validation(ref cause) => cause,
DescribeDBClusterParameterGroupsError::Credentials(ref err) => err.description(),
DescribeDBClusterParameterGroupsError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DescribeDBClusterParameterGroupsError::ParseError(ref cause) => cause,
DescribeDBClusterParameterGroupsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeDBClusterParametersError {
DBParameterGroupNotFoundFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeDBClusterParametersError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeDBClusterParametersError {
{
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[..] {
"DBParameterGroupNotFound" => {
return DescribeDBClusterParametersError::DBParameterGroupNotFoundFault(
String::from(parsed_error.message),
);
}
_ => {}
}
}
}
DescribeDBClusterParametersError::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 DescribeDBClusterParametersError {
fn from(err: XmlParseError) -> DescribeDBClusterParametersError {
let XmlParseError(message) = err;
DescribeDBClusterParametersError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DescribeDBClusterParametersError {
fn from(err: CredentialsError) -> DescribeDBClusterParametersError {
DescribeDBClusterParametersError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeDBClusterParametersError {
fn from(err: HttpDispatchError) -> DescribeDBClusterParametersError {
DescribeDBClusterParametersError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeDBClusterParametersError {
fn from(err: io::Error) -> DescribeDBClusterParametersError {
DescribeDBClusterParametersError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeDBClusterParametersError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeDBClusterParametersError {
fn description(&self) -> &str {
match *self {
DescribeDBClusterParametersError::DBParameterGroupNotFoundFault(ref cause) => cause,
DescribeDBClusterParametersError::Validation(ref cause) => cause,
DescribeDBClusterParametersError::Credentials(ref err) => err.description(),
DescribeDBClusterParametersError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DescribeDBClusterParametersError::ParseError(ref cause) => cause,
DescribeDBClusterParametersError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeDBClusterSnapshotAttributesError {
DBClusterSnapshotNotFoundFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeDBClusterSnapshotAttributesError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeDBClusterSnapshotAttributesError {
{
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[..] {
"DBClusterSnapshotNotFoundFault" => return DescribeDBClusterSnapshotAttributesError::DBClusterSnapshotNotFoundFault(String::from(parsed_error.message)),_ => {}
}
}
}
DescribeDBClusterSnapshotAttributesError::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 DescribeDBClusterSnapshotAttributesError {
fn from(err: XmlParseError) -> DescribeDBClusterSnapshotAttributesError {
let XmlParseError(message) = err;
DescribeDBClusterSnapshotAttributesError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DescribeDBClusterSnapshotAttributesError {
fn from(err: CredentialsError) -> DescribeDBClusterSnapshotAttributesError {
DescribeDBClusterSnapshotAttributesError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeDBClusterSnapshotAttributesError {
fn from(err: HttpDispatchError) -> DescribeDBClusterSnapshotAttributesError {
DescribeDBClusterSnapshotAttributesError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeDBClusterSnapshotAttributesError {
fn from(err: io::Error) -> DescribeDBClusterSnapshotAttributesError {
DescribeDBClusterSnapshotAttributesError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeDBClusterSnapshotAttributesError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeDBClusterSnapshotAttributesError {
fn description(&self) -> &str {
match *self {
DescribeDBClusterSnapshotAttributesError::DBClusterSnapshotNotFoundFault(ref cause) => {
cause
}
DescribeDBClusterSnapshotAttributesError::Validation(ref cause) => cause,
DescribeDBClusterSnapshotAttributesError::Credentials(ref err) => err.description(),
DescribeDBClusterSnapshotAttributesError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DescribeDBClusterSnapshotAttributesError::ParseError(ref cause) => cause,
DescribeDBClusterSnapshotAttributesError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeDBClusterSnapshotsError {
DBClusterSnapshotNotFoundFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeDBClusterSnapshotsError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeDBClusterSnapshotsError {
{
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[..] {
"DBClusterSnapshotNotFoundFault" => {
return DescribeDBClusterSnapshotsError::DBClusterSnapshotNotFoundFault(
String::from(parsed_error.message),
);
}
_ => {}
}
}
}
DescribeDBClusterSnapshotsError::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 DescribeDBClusterSnapshotsError {
fn from(err: XmlParseError) -> DescribeDBClusterSnapshotsError {
let XmlParseError(message) = err;
DescribeDBClusterSnapshotsError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DescribeDBClusterSnapshotsError {
fn from(err: CredentialsError) -> DescribeDBClusterSnapshotsError {
DescribeDBClusterSnapshotsError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeDBClusterSnapshotsError {
fn from(err: HttpDispatchError) -> DescribeDBClusterSnapshotsError {
DescribeDBClusterSnapshotsError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeDBClusterSnapshotsError {
fn from(err: io::Error) -> DescribeDBClusterSnapshotsError {
DescribeDBClusterSnapshotsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeDBClusterSnapshotsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeDBClusterSnapshotsError {
fn description(&self) -> &str {
match *self {
DescribeDBClusterSnapshotsError::DBClusterSnapshotNotFoundFault(ref cause) => cause,
DescribeDBClusterSnapshotsError::Validation(ref cause) => cause,
DescribeDBClusterSnapshotsError::Credentials(ref err) => err.description(),
DescribeDBClusterSnapshotsError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DescribeDBClusterSnapshotsError::ParseError(ref cause) => cause,
DescribeDBClusterSnapshotsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeDBClustersError {
DBClusterNotFoundFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeDBClustersError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeDBClustersError {
{
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[..] {
"DBClusterNotFoundFault" => {
return DescribeDBClustersError::DBClusterNotFoundFault(String::from(
parsed_error.message,
));
}
_ => {}
}
}
}
DescribeDBClustersError::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 DescribeDBClustersError {
fn from(err: XmlParseError) -> DescribeDBClustersError {
let XmlParseError(message) = err;
DescribeDBClustersError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DescribeDBClustersError {
fn from(err: CredentialsError) -> DescribeDBClustersError {
DescribeDBClustersError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeDBClustersError {
fn from(err: HttpDispatchError) -> DescribeDBClustersError {
DescribeDBClustersError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeDBClustersError {
fn from(err: io::Error) -> DescribeDBClustersError {
DescribeDBClustersError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeDBClustersError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeDBClustersError {
fn description(&self) -> &str {
match *self {
DescribeDBClustersError::DBClusterNotFoundFault(ref cause) => cause,
DescribeDBClustersError::Validation(ref cause) => cause,
DescribeDBClustersError::Credentials(ref err) => err.description(),
DescribeDBClustersError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DescribeDBClustersError::ParseError(ref cause) => cause,
DescribeDBClustersError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeDBEngineVersionsError {
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeDBEngineVersionsError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeDBEngineVersionsError {
{
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[..] {
_ => {}
}
}
}
DescribeDBEngineVersionsError::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 DescribeDBEngineVersionsError {
fn from(err: XmlParseError) -> DescribeDBEngineVersionsError {
let XmlParseError(message) = err;
DescribeDBEngineVersionsError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DescribeDBEngineVersionsError {
fn from(err: CredentialsError) -> DescribeDBEngineVersionsError {
DescribeDBEngineVersionsError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeDBEngineVersionsError {
fn from(err: HttpDispatchError) -> DescribeDBEngineVersionsError {
DescribeDBEngineVersionsError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeDBEngineVersionsError {
fn from(err: io::Error) -> DescribeDBEngineVersionsError {
DescribeDBEngineVersionsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeDBEngineVersionsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeDBEngineVersionsError {
fn description(&self) -> &str {
match *self {
DescribeDBEngineVersionsError::Validation(ref cause) => cause,
DescribeDBEngineVersionsError::Credentials(ref err) => err.description(),
DescribeDBEngineVersionsError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DescribeDBEngineVersionsError::ParseError(ref cause) => cause,
DescribeDBEngineVersionsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeDBInstancesError {
DBInstanceNotFoundFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeDBInstancesError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeDBInstancesError {
{
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[..] {
"DBInstanceNotFound" => {
return DescribeDBInstancesError::DBInstanceNotFoundFault(String::from(
parsed_error.message,
));
}
_ => {}
}
}
}
DescribeDBInstancesError::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 DescribeDBInstancesError {
fn from(err: XmlParseError) -> DescribeDBInstancesError {
let XmlParseError(message) = err;
DescribeDBInstancesError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DescribeDBInstancesError {
fn from(err: CredentialsError) -> DescribeDBInstancesError {
DescribeDBInstancesError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeDBInstancesError {
fn from(err: HttpDispatchError) -> DescribeDBInstancesError {
DescribeDBInstancesError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeDBInstancesError {
fn from(err: io::Error) -> DescribeDBInstancesError {
DescribeDBInstancesError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeDBInstancesError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeDBInstancesError {
fn description(&self) -> &str {
match *self {
DescribeDBInstancesError::DBInstanceNotFoundFault(ref cause) => cause,
DescribeDBInstancesError::Validation(ref cause) => cause,
DescribeDBInstancesError::Credentials(ref err) => err.description(),
DescribeDBInstancesError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DescribeDBInstancesError::ParseError(ref cause) => cause,
DescribeDBInstancesError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeDBParameterGroupsError {
DBParameterGroupNotFoundFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeDBParameterGroupsError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeDBParameterGroupsError {
{
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[..] {
"DBParameterGroupNotFound" => {
return DescribeDBParameterGroupsError::DBParameterGroupNotFoundFault(
String::from(parsed_error.message),
);
}
_ => {}
}
}
}
DescribeDBParameterGroupsError::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 DescribeDBParameterGroupsError {
fn from(err: XmlParseError) -> DescribeDBParameterGroupsError {
let XmlParseError(message) = err;
DescribeDBParameterGroupsError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DescribeDBParameterGroupsError {
fn from(err: CredentialsError) -> DescribeDBParameterGroupsError {
DescribeDBParameterGroupsError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeDBParameterGroupsError {
fn from(err: HttpDispatchError) -> DescribeDBParameterGroupsError {
DescribeDBParameterGroupsError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeDBParameterGroupsError {
fn from(err: io::Error) -> DescribeDBParameterGroupsError {
DescribeDBParameterGroupsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeDBParameterGroupsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeDBParameterGroupsError {
fn description(&self) -> &str {
match *self {
DescribeDBParameterGroupsError::DBParameterGroupNotFoundFault(ref cause) => cause,
DescribeDBParameterGroupsError::Validation(ref cause) => cause,
DescribeDBParameterGroupsError::Credentials(ref err) => err.description(),
DescribeDBParameterGroupsError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DescribeDBParameterGroupsError::ParseError(ref cause) => cause,
DescribeDBParameterGroupsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeDBParametersError {
DBParameterGroupNotFoundFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeDBParametersError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeDBParametersError {
{
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[..] {
"DBParameterGroupNotFound" => {
return DescribeDBParametersError::DBParameterGroupNotFoundFault(
String::from(parsed_error.message),
);
}
_ => {}
}
}
}
DescribeDBParametersError::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 DescribeDBParametersError {
fn from(err: XmlParseError) -> DescribeDBParametersError {
let XmlParseError(message) = err;
DescribeDBParametersError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DescribeDBParametersError {
fn from(err: CredentialsError) -> DescribeDBParametersError {
DescribeDBParametersError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeDBParametersError {
fn from(err: HttpDispatchError) -> DescribeDBParametersError {
DescribeDBParametersError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeDBParametersError {
fn from(err: io::Error) -> DescribeDBParametersError {
DescribeDBParametersError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeDBParametersError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeDBParametersError {
fn description(&self) -> &str {
match *self {
DescribeDBParametersError::DBParameterGroupNotFoundFault(ref cause) => cause,
DescribeDBParametersError::Validation(ref cause) => cause,
DescribeDBParametersError::Credentials(ref err) => err.description(),
DescribeDBParametersError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DescribeDBParametersError::ParseError(ref cause) => cause,
DescribeDBParametersError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeDBSubnetGroupsError {
DBSubnetGroupNotFoundFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeDBSubnetGroupsError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeDBSubnetGroupsError {
{
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[..] {
"DBSubnetGroupNotFoundFault" => {
return DescribeDBSubnetGroupsError::DBSubnetGroupNotFoundFault(
String::from(parsed_error.message),
);
}
_ => {}
}
}
}
DescribeDBSubnetGroupsError::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 DescribeDBSubnetGroupsError {
fn from(err: XmlParseError) -> DescribeDBSubnetGroupsError {
let XmlParseError(message) = err;
DescribeDBSubnetGroupsError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DescribeDBSubnetGroupsError {
fn from(err: CredentialsError) -> DescribeDBSubnetGroupsError {
DescribeDBSubnetGroupsError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeDBSubnetGroupsError {
fn from(err: HttpDispatchError) -> DescribeDBSubnetGroupsError {
DescribeDBSubnetGroupsError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeDBSubnetGroupsError {
fn from(err: io::Error) -> DescribeDBSubnetGroupsError {
DescribeDBSubnetGroupsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeDBSubnetGroupsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeDBSubnetGroupsError {
fn description(&self) -> &str {
match *self {
DescribeDBSubnetGroupsError::DBSubnetGroupNotFoundFault(ref cause) => cause,
DescribeDBSubnetGroupsError::Validation(ref cause) => cause,
DescribeDBSubnetGroupsError::Credentials(ref err) => err.description(),
DescribeDBSubnetGroupsError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DescribeDBSubnetGroupsError::ParseError(ref cause) => cause,
DescribeDBSubnetGroupsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeEngineDefaultClusterParametersError {
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeEngineDefaultClusterParametersError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeEngineDefaultClusterParametersError {
{
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[..] {
_ => {}
}
}
}
DescribeEngineDefaultClusterParametersError::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 DescribeEngineDefaultClusterParametersError {
fn from(err: XmlParseError) -> DescribeEngineDefaultClusterParametersError {
let XmlParseError(message) = err;
DescribeEngineDefaultClusterParametersError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DescribeEngineDefaultClusterParametersError {
fn from(err: CredentialsError) -> DescribeEngineDefaultClusterParametersError {
DescribeEngineDefaultClusterParametersError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeEngineDefaultClusterParametersError {
fn from(err: HttpDispatchError) -> DescribeEngineDefaultClusterParametersError {
DescribeEngineDefaultClusterParametersError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeEngineDefaultClusterParametersError {
fn from(err: io::Error) -> DescribeEngineDefaultClusterParametersError {
DescribeEngineDefaultClusterParametersError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeEngineDefaultClusterParametersError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeEngineDefaultClusterParametersError {
fn description(&self) -> &str {
match *self {
DescribeEngineDefaultClusterParametersError::Validation(ref cause) => cause,
DescribeEngineDefaultClusterParametersError::Credentials(ref err) => err.description(),
DescribeEngineDefaultClusterParametersError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DescribeEngineDefaultClusterParametersError::ParseError(ref cause) => cause,
DescribeEngineDefaultClusterParametersError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeEngineDefaultParametersError {
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeEngineDefaultParametersError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeEngineDefaultParametersError {
{
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[..] {
_ => {}
}
}
}
DescribeEngineDefaultParametersError::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 DescribeEngineDefaultParametersError {
fn from(err: XmlParseError) -> DescribeEngineDefaultParametersError {
let XmlParseError(message) = err;
DescribeEngineDefaultParametersError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DescribeEngineDefaultParametersError {
fn from(err: CredentialsError) -> DescribeEngineDefaultParametersError {
DescribeEngineDefaultParametersError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeEngineDefaultParametersError {
fn from(err: HttpDispatchError) -> DescribeEngineDefaultParametersError {
DescribeEngineDefaultParametersError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeEngineDefaultParametersError {
fn from(err: io::Error) -> DescribeEngineDefaultParametersError {
DescribeEngineDefaultParametersError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeEngineDefaultParametersError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeEngineDefaultParametersError {
fn description(&self) -> &str {
match *self {
DescribeEngineDefaultParametersError::Validation(ref cause) => cause,
DescribeEngineDefaultParametersError::Credentials(ref err) => err.description(),
DescribeEngineDefaultParametersError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DescribeEngineDefaultParametersError::ParseError(ref cause) => cause,
DescribeEngineDefaultParametersError::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 {
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[..] {
"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::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 DescribeOrderableDBInstanceOptionsError {
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeOrderableDBInstanceOptionsError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeOrderableDBInstanceOptionsError {
{
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[..] {
_ => {}
}
}
}
DescribeOrderableDBInstanceOptionsError::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 DescribeOrderableDBInstanceOptionsError {
fn from(err: XmlParseError) -> DescribeOrderableDBInstanceOptionsError {
let XmlParseError(message) = err;
DescribeOrderableDBInstanceOptionsError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DescribeOrderableDBInstanceOptionsError {
fn from(err: CredentialsError) -> DescribeOrderableDBInstanceOptionsError {
DescribeOrderableDBInstanceOptionsError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeOrderableDBInstanceOptionsError {
fn from(err: HttpDispatchError) -> DescribeOrderableDBInstanceOptionsError {
DescribeOrderableDBInstanceOptionsError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeOrderableDBInstanceOptionsError {
fn from(err: io::Error) -> DescribeOrderableDBInstanceOptionsError {
DescribeOrderableDBInstanceOptionsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeOrderableDBInstanceOptionsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeOrderableDBInstanceOptionsError {
fn description(&self) -> &str {
match *self {
DescribeOrderableDBInstanceOptionsError::Validation(ref cause) => cause,
DescribeOrderableDBInstanceOptionsError::Credentials(ref err) => err.description(),
DescribeOrderableDBInstanceOptionsError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DescribeOrderableDBInstanceOptionsError::ParseError(ref cause) => cause,
DescribeOrderableDBInstanceOptionsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribePendingMaintenanceActionsError {
ResourceNotFoundFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribePendingMaintenanceActionsError {
pub fn from_response(res: BufferedHttpResponse) -> DescribePendingMaintenanceActionsError {
{
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[..] {
"ResourceNotFoundFault" => {
return DescribePendingMaintenanceActionsError::ResourceNotFoundFault(
String::from(parsed_error.message),
);
}
_ => {}
}
}
}
DescribePendingMaintenanceActionsError::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 DescribePendingMaintenanceActionsError {
fn from(err: XmlParseError) -> DescribePendingMaintenanceActionsError {
let XmlParseError(message) = err;
DescribePendingMaintenanceActionsError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DescribePendingMaintenanceActionsError {
fn from(err: CredentialsError) -> DescribePendingMaintenanceActionsError {
DescribePendingMaintenanceActionsError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribePendingMaintenanceActionsError {
fn from(err: HttpDispatchError) -> DescribePendingMaintenanceActionsError {
DescribePendingMaintenanceActionsError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribePendingMaintenanceActionsError {
fn from(err: io::Error) -> DescribePendingMaintenanceActionsError {
DescribePendingMaintenanceActionsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribePendingMaintenanceActionsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribePendingMaintenanceActionsError {
fn description(&self) -> &str {
match *self {
DescribePendingMaintenanceActionsError::ResourceNotFoundFault(ref cause) => cause,
DescribePendingMaintenanceActionsError::Validation(ref cause) => cause,
DescribePendingMaintenanceActionsError::Credentials(ref err) => err.description(),
DescribePendingMaintenanceActionsError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DescribePendingMaintenanceActionsError::ParseError(ref cause) => cause,
DescribePendingMaintenanceActionsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeValidDBInstanceModificationsError {
DBInstanceNotFoundFault(String),
InvalidDBInstanceStateFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeValidDBInstanceModificationsError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeValidDBInstanceModificationsError {
{
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[..] {
"DBInstanceNotFound" => return DescribeValidDBInstanceModificationsError::DBInstanceNotFoundFault(String::from(parsed_error.message)),"InvalidDBInstanceState" => return DescribeValidDBInstanceModificationsError::InvalidDBInstanceStateFault(String::from(parsed_error.message)),_ => {}
}
}
}
DescribeValidDBInstanceModificationsError::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 DescribeValidDBInstanceModificationsError {
fn from(err: XmlParseError) -> DescribeValidDBInstanceModificationsError {
let XmlParseError(message) = err;
DescribeValidDBInstanceModificationsError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DescribeValidDBInstanceModificationsError {
fn from(err: CredentialsError) -> DescribeValidDBInstanceModificationsError {
DescribeValidDBInstanceModificationsError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeValidDBInstanceModificationsError {
fn from(err: HttpDispatchError) -> DescribeValidDBInstanceModificationsError {
DescribeValidDBInstanceModificationsError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeValidDBInstanceModificationsError {
fn from(err: io::Error) -> DescribeValidDBInstanceModificationsError {
DescribeValidDBInstanceModificationsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeValidDBInstanceModificationsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeValidDBInstanceModificationsError {
fn description(&self) -> &str {
match *self {
DescribeValidDBInstanceModificationsError::DBInstanceNotFoundFault(ref cause) => cause,
DescribeValidDBInstanceModificationsError::InvalidDBInstanceStateFault(ref cause) => {
cause
}
DescribeValidDBInstanceModificationsError::Validation(ref cause) => cause,
DescribeValidDBInstanceModificationsError::Credentials(ref err) => err.description(),
DescribeValidDBInstanceModificationsError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DescribeValidDBInstanceModificationsError::ParseError(ref cause) => cause,
DescribeValidDBInstanceModificationsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum FailoverDBClusterError {
DBClusterNotFoundFault(String),
InvalidDBClusterStateFault(String),
InvalidDBInstanceStateFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl FailoverDBClusterError {
pub fn from_response(res: BufferedHttpResponse) -> FailoverDBClusterError {
{
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[..] {
"DBClusterNotFoundFault" => {
return FailoverDBClusterError::DBClusterNotFoundFault(String::from(
parsed_error.message,
));
}
"InvalidDBClusterStateFault" => {
return FailoverDBClusterError::InvalidDBClusterStateFault(String::from(
parsed_error.message,
));
}
"InvalidDBInstanceState" => {
return FailoverDBClusterError::InvalidDBInstanceStateFault(String::from(
parsed_error.message,
));
}
_ => {}
}
}
}
FailoverDBClusterError::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 FailoverDBClusterError {
fn from(err: XmlParseError) -> FailoverDBClusterError {
let XmlParseError(message) = err;
FailoverDBClusterError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for FailoverDBClusterError {
fn from(err: CredentialsError) -> FailoverDBClusterError {
FailoverDBClusterError::Credentials(err)
}
}
impl From<HttpDispatchError> for FailoverDBClusterError {
fn from(err: HttpDispatchError) -> FailoverDBClusterError {
FailoverDBClusterError::HttpDispatch(err)
}
}
impl From<io::Error> for FailoverDBClusterError {
fn from(err: io::Error) -> FailoverDBClusterError {
FailoverDBClusterError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for FailoverDBClusterError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for FailoverDBClusterError {
fn description(&self) -> &str {
match *self {
FailoverDBClusterError::DBClusterNotFoundFault(ref cause) => cause,
FailoverDBClusterError::InvalidDBClusterStateFault(ref cause) => cause,
FailoverDBClusterError::InvalidDBInstanceStateFault(ref cause) => cause,
FailoverDBClusterError::Validation(ref cause) => cause,
FailoverDBClusterError::Credentials(ref err) => err.description(),
FailoverDBClusterError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
FailoverDBClusterError::ParseError(ref cause) => cause,
FailoverDBClusterError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ListTagsForResourceError {
DBClusterNotFoundFault(String),
DBInstanceNotFoundFault(String),
DBSnapshotNotFoundFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ListTagsForResourceError {
pub fn from_response(res: BufferedHttpResponse) -> ListTagsForResourceError {
{
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[..] {
"DBClusterNotFoundFault" => {
return ListTagsForResourceError::DBClusterNotFoundFault(String::from(
parsed_error.message,
));
}
"DBInstanceNotFound" => {
return ListTagsForResourceError::DBInstanceNotFoundFault(String::from(
parsed_error.message,
));
}
"DBSnapshotNotFound" => {
return ListTagsForResourceError::DBSnapshotNotFoundFault(String::from(
parsed_error.message,
));
}
_ => {}
}
}
}
ListTagsForResourceError::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 ListTagsForResourceError {
fn from(err: XmlParseError) -> ListTagsForResourceError {
let XmlParseError(message) = err;
ListTagsForResourceError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for ListTagsForResourceError {
fn from(err: CredentialsError) -> ListTagsForResourceError {
ListTagsForResourceError::Credentials(err)
}
}
impl From<HttpDispatchError> for ListTagsForResourceError {
fn from(err: HttpDispatchError) -> ListTagsForResourceError {
ListTagsForResourceError::HttpDispatch(err)
}
}
impl From<io::Error> for ListTagsForResourceError {
fn from(err: io::Error) -> ListTagsForResourceError {
ListTagsForResourceError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ListTagsForResourceError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ListTagsForResourceError {
fn description(&self) -> &str {
match *self {
ListTagsForResourceError::DBClusterNotFoundFault(ref cause) => cause,
ListTagsForResourceError::DBInstanceNotFoundFault(ref cause) => cause,
ListTagsForResourceError::DBSnapshotNotFoundFault(ref cause) => cause,
ListTagsForResourceError::Validation(ref cause) => cause,
ListTagsForResourceError::Credentials(ref err) => err.description(),
ListTagsForResourceError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
ListTagsForResourceError::ParseError(ref cause) => cause,
ListTagsForResourceError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ModifyDBClusterError {
DBClusterAlreadyExistsFault(String),
DBClusterNotFoundFault(String),
DBClusterParameterGroupNotFoundFault(String),
DBSubnetGroupNotFoundFault(String),
InvalidDBClusterStateFault(String),
InvalidDBInstanceStateFault(String),
InvalidDBSecurityGroupStateFault(String),
InvalidDBSubnetGroupStateFault(String),
InvalidSubnet(String),
InvalidVPCNetworkStateFault(String),
StorageQuotaExceededFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ModifyDBClusterError {
pub fn from_response(res: BufferedHttpResponse) -> ModifyDBClusterError {
{
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[..] {
"DBClusterAlreadyExistsFault" => {
return ModifyDBClusterError::DBClusterAlreadyExistsFault(String::from(
parsed_error.message,
));
}
"DBClusterNotFoundFault" => {
return ModifyDBClusterError::DBClusterNotFoundFault(String::from(
parsed_error.message,
));
}
"DBClusterParameterGroupNotFound" => {
return ModifyDBClusterError::DBClusterParameterGroupNotFoundFault(
String::from(parsed_error.message),
);
}
"DBSubnetGroupNotFoundFault" => {
return ModifyDBClusterError::DBSubnetGroupNotFoundFault(String::from(
parsed_error.message,
));
}
"InvalidDBClusterStateFault" => {
return ModifyDBClusterError::InvalidDBClusterStateFault(String::from(
parsed_error.message,
));
}
"InvalidDBInstanceState" => {
return ModifyDBClusterError::InvalidDBInstanceStateFault(String::from(
parsed_error.message,
));
}
"InvalidDBSecurityGroupState" => {
return ModifyDBClusterError::InvalidDBSecurityGroupStateFault(String::from(
parsed_error.message,
));
}
"InvalidDBSubnetGroupStateFault" => {
return ModifyDBClusterError::InvalidDBSubnetGroupStateFault(String::from(
parsed_error.message,
));
}
"InvalidSubnet" => {
return ModifyDBClusterError::InvalidSubnet(String::from(
parsed_error.message,
));
}
"InvalidVPCNetworkStateFault" => {
return ModifyDBClusterError::InvalidVPCNetworkStateFault(String::from(
parsed_error.message,
));
}
"StorageQuotaExceeded" => {
return ModifyDBClusterError::StorageQuotaExceededFault(String::from(
parsed_error.message,
));
}
_ => {}
}
}
}
ModifyDBClusterError::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 ModifyDBClusterError {
fn from(err: XmlParseError) -> ModifyDBClusterError {
let XmlParseError(message) = err;
ModifyDBClusterError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for ModifyDBClusterError {
fn from(err: CredentialsError) -> ModifyDBClusterError {
ModifyDBClusterError::Credentials(err)
}
}
impl From<HttpDispatchError> for ModifyDBClusterError {
fn from(err: HttpDispatchError) -> ModifyDBClusterError {
ModifyDBClusterError::HttpDispatch(err)
}
}
impl From<io::Error> for ModifyDBClusterError {
fn from(err: io::Error) -> ModifyDBClusterError {
ModifyDBClusterError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ModifyDBClusterError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ModifyDBClusterError {
fn description(&self) -> &str {
match *self {
ModifyDBClusterError::DBClusterAlreadyExistsFault(ref cause) => cause,
ModifyDBClusterError::DBClusterNotFoundFault(ref cause) => cause,
ModifyDBClusterError::DBClusterParameterGroupNotFoundFault(ref cause) => cause,
ModifyDBClusterError::DBSubnetGroupNotFoundFault(ref cause) => cause,
ModifyDBClusterError::InvalidDBClusterStateFault(ref cause) => cause,
ModifyDBClusterError::InvalidDBInstanceStateFault(ref cause) => cause,
ModifyDBClusterError::InvalidDBSecurityGroupStateFault(ref cause) => cause,
ModifyDBClusterError::InvalidDBSubnetGroupStateFault(ref cause) => cause,
ModifyDBClusterError::InvalidSubnet(ref cause) => cause,
ModifyDBClusterError::InvalidVPCNetworkStateFault(ref cause) => cause,
ModifyDBClusterError::StorageQuotaExceededFault(ref cause) => cause,
ModifyDBClusterError::Validation(ref cause) => cause,
ModifyDBClusterError::Credentials(ref err) => err.description(),
ModifyDBClusterError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
ModifyDBClusterError::ParseError(ref cause) => cause,
ModifyDBClusterError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ModifyDBClusterParameterGroupError {
DBParameterGroupNotFoundFault(String),
InvalidDBParameterGroupStateFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ModifyDBClusterParameterGroupError {
pub fn from_response(res: BufferedHttpResponse) -> ModifyDBClusterParameterGroupError {
{
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[..] {
"DBParameterGroupNotFound" => {
return ModifyDBClusterParameterGroupError::DBParameterGroupNotFoundFault(
String::from(parsed_error.message),
);
}
"InvalidDBParameterGroupState" => {
return ModifyDBClusterParameterGroupError::InvalidDBParameterGroupStateFault(
String::from(parsed_error.message),
);
}
_ => {}
}
}
}
ModifyDBClusterParameterGroupError::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 ModifyDBClusterParameterGroupError {
fn from(err: XmlParseError) -> ModifyDBClusterParameterGroupError {
let XmlParseError(message) = err;
ModifyDBClusterParameterGroupError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for ModifyDBClusterParameterGroupError {
fn from(err: CredentialsError) -> ModifyDBClusterParameterGroupError {
ModifyDBClusterParameterGroupError::Credentials(err)
}
}
impl From<HttpDispatchError> for ModifyDBClusterParameterGroupError {
fn from(err: HttpDispatchError) -> ModifyDBClusterParameterGroupError {
ModifyDBClusterParameterGroupError::HttpDispatch(err)
}
}
impl From<io::Error> for ModifyDBClusterParameterGroupError {
fn from(err: io::Error) -> ModifyDBClusterParameterGroupError {
ModifyDBClusterParameterGroupError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ModifyDBClusterParameterGroupError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ModifyDBClusterParameterGroupError {
fn description(&self) -> &str {
match *self {
ModifyDBClusterParameterGroupError::DBParameterGroupNotFoundFault(ref cause) => cause,
ModifyDBClusterParameterGroupError::InvalidDBParameterGroupStateFault(ref cause) => {
cause
}
ModifyDBClusterParameterGroupError::Validation(ref cause) => cause,
ModifyDBClusterParameterGroupError::Credentials(ref err) => err.description(),
ModifyDBClusterParameterGroupError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
ModifyDBClusterParameterGroupError::ParseError(ref cause) => cause,
ModifyDBClusterParameterGroupError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ModifyDBClusterSnapshotAttributeError {
DBClusterSnapshotNotFoundFault(String),
InvalidDBClusterSnapshotStateFault(String),
SharedSnapshotQuotaExceededFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ModifyDBClusterSnapshotAttributeError {
pub fn from_response(res: BufferedHttpResponse) -> ModifyDBClusterSnapshotAttributeError {
{
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[..] {
"DBClusterSnapshotNotFoundFault" => return ModifyDBClusterSnapshotAttributeError::DBClusterSnapshotNotFoundFault(String::from(parsed_error.message)),"InvalidDBClusterSnapshotStateFault" => return ModifyDBClusterSnapshotAttributeError::InvalidDBClusterSnapshotStateFault(String::from(parsed_error.message)),"SharedSnapshotQuotaExceeded" => return ModifyDBClusterSnapshotAttributeError::SharedSnapshotQuotaExceededFault(String::from(parsed_error.message)),_ => {}
}
}
}
ModifyDBClusterSnapshotAttributeError::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 ModifyDBClusterSnapshotAttributeError {
fn from(err: XmlParseError) -> ModifyDBClusterSnapshotAttributeError {
let XmlParseError(message) = err;
ModifyDBClusterSnapshotAttributeError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for ModifyDBClusterSnapshotAttributeError {
fn from(err: CredentialsError) -> ModifyDBClusterSnapshotAttributeError {
ModifyDBClusterSnapshotAttributeError::Credentials(err)
}
}
impl From<HttpDispatchError> for ModifyDBClusterSnapshotAttributeError {
fn from(err: HttpDispatchError) -> ModifyDBClusterSnapshotAttributeError {
ModifyDBClusterSnapshotAttributeError::HttpDispatch(err)
}
}
impl From<io::Error> for ModifyDBClusterSnapshotAttributeError {
fn from(err: io::Error) -> ModifyDBClusterSnapshotAttributeError {
ModifyDBClusterSnapshotAttributeError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ModifyDBClusterSnapshotAttributeError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ModifyDBClusterSnapshotAttributeError {
fn description(&self) -> &str {
match *self {
ModifyDBClusterSnapshotAttributeError::DBClusterSnapshotNotFoundFault(ref cause) => {
cause
}
ModifyDBClusterSnapshotAttributeError::InvalidDBClusterSnapshotStateFault(
ref cause,
) => cause,
ModifyDBClusterSnapshotAttributeError::SharedSnapshotQuotaExceededFault(ref cause) => {
cause
}
ModifyDBClusterSnapshotAttributeError::Validation(ref cause) => cause,
ModifyDBClusterSnapshotAttributeError::Credentials(ref err) => err.description(),
ModifyDBClusterSnapshotAttributeError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
ModifyDBClusterSnapshotAttributeError::ParseError(ref cause) => cause,
ModifyDBClusterSnapshotAttributeError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ModifyDBInstanceError {
AuthorizationNotFoundFault(String),
CertificateNotFoundFault(String),
DBInstanceAlreadyExistsFault(String),
DBInstanceNotFoundFault(String),
DBParameterGroupNotFoundFault(String),
DBSecurityGroupNotFoundFault(String),
DBUpgradeDependencyFailureFault(String),
DomainNotFoundFault(String),
InsufficientDBInstanceCapacityFault(String),
InvalidDBInstanceStateFault(String),
InvalidDBSecurityGroupStateFault(String),
InvalidVPCNetworkStateFault(String),
OptionGroupNotFoundFault(String),
ProvisionedIopsNotAvailableInAZFault(String),
StorageQuotaExceededFault(String),
StorageTypeNotSupportedFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ModifyDBInstanceError {
pub fn from_response(res: BufferedHttpResponse) -> ModifyDBInstanceError {
{
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 ModifyDBInstanceError::AuthorizationNotFoundFault(String::from(
parsed_error.message,
));
}
"CertificateNotFound" => {
return ModifyDBInstanceError::CertificateNotFoundFault(String::from(
parsed_error.message,
));
}
"DBInstanceAlreadyExists" => {
return ModifyDBInstanceError::DBInstanceAlreadyExistsFault(String::from(
parsed_error.message,
));
}
"DBInstanceNotFound" => {
return ModifyDBInstanceError::DBInstanceNotFoundFault(String::from(
parsed_error.message,
));
}
"DBParameterGroupNotFound" => {
return ModifyDBInstanceError::DBParameterGroupNotFoundFault(String::from(
parsed_error.message,
));
}
"DBSecurityGroupNotFound" => {
return ModifyDBInstanceError::DBSecurityGroupNotFoundFault(String::from(
parsed_error.message,
));
}
"DBUpgradeDependencyFailure" => {
return ModifyDBInstanceError::DBUpgradeDependencyFailureFault(String::from(
parsed_error.message,
));
}
"DomainNotFoundFault" => {
return ModifyDBInstanceError::DomainNotFoundFault(String::from(
parsed_error.message,
));
}
"InsufficientDBInstanceCapacity" => {
return ModifyDBInstanceError::InsufficientDBInstanceCapacityFault(
String::from(parsed_error.message),
);
}
"InvalidDBInstanceState" => {
return ModifyDBInstanceError::InvalidDBInstanceStateFault(String::from(
parsed_error.message,
));
}
"InvalidDBSecurityGroupState" => {
return ModifyDBInstanceError::InvalidDBSecurityGroupStateFault(
String::from(parsed_error.message),
);
}
"InvalidVPCNetworkStateFault" => {
return ModifyDBInstanceError::InvalidVPCNetworkStateFault(String::from(
parsed_error.message,
));
}
"OptionGroupNotFoundFault" => {
return ModifyDBInstanceError::OptionGroupNotFoundFault(String::from(
parsed_error.message,
));
}
"ProvisionedIopsNotAvailableInAZFault" => {
return ModifyDBInstanceError::ProvisionedIopsNotAvailableInAZFault(
String::from(parsed_error.message),
);
}
"StorageQuotaExceeded" => {
return ModifyDBInstanceError::StorageQuotaExceededFault(String::from(
parsed_error.message,
));
}
"StorageTypeNotSupported" => {
return ModifyDBInstanceError::StorageTypeNotSupportedFault(String::from(
parsed_error.message,
));
}
_ => {}
}
}
}
ModifyDBInstanceError::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 ModifyDBInstanceError {
fn from(err: XmlParseError) -> ModifyDBInstanceError {
let XmlParseError(message) = err;
ModifyDBInstanceError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for ModifyDBInstanceError {
fn from(err: CredentialsError) -> ModifyDBInstanceError {
ModifyDBInstanceError::Credentials(err)
}
}
impl From<HttpDispatchError> for ModifyDBInstanceError {
fn from(err: HttpDispatchError) -> ModifyDBInstanceError {
ModifyDBInstanceError::HttpDispatch(err)
}
}
impl From<io::Error> for ModifyDBInstanceError {
fn from(err: io::Error) -> ModifyDBInstanceError {
ModifyDBInstanceError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ModifyDBInstanceError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ModifyDBInstanceError {
fn description(&self) -> &str {
match *self {
ModifyDBInstanceError::AuthorizationNotFoundFault(ref cause) => cause,
ModifyDBInstanceError::CertificateNotFoundFault(ref cause) => cause,
ModifyDBInstanceError::DBInstanceAlreadyExistsFault(ref cause) => cause,
ModifyDBInstanceError::DBInstanceNotFoundFault(ref cause) => cause,
ModifyDBInstanceError::DBParameterGroupNotFoundFault(ref cause) => cause,
ModifyDBInstanceError::DBSecurityGroupNotFoundFault(ref cause) => cause,
ModifyDBInstanceError::DBUpgradeDependencyFailureFault(ref cause) => cause,
ModifyDBInstanceError::DomainNotFoundFault(ref cause) => cause,
ModifyDBInstanceError::InsufficientDBInstanceCapacityFault(ref cause) => cause,
ModifyDBInstanceError::InvalidDBInstanceStateFault(ref cause) => cause,
ModifyDBInstanceError::InvalidDBSecurityGroupStateFault(ref cause) => cause,
ModifyDBInstanceError::InvalidVPCNetworkStateFault(ref cause) => cause,
ModifyDBInstanceError::OptionGroupNotFoundFault(ref cause) => cause,
ModifyDBInstanceError::ProvisionedIopsNotAvailableInAZFault(ref cause) => cause,
ModifyDBInstanceError::StorageQuotaExceededFault(ref cause) => cause,
ModifyDBInstanceError::StorageTypeNotSupportedFault(ref cause) => cause,
ModifyDBInstanceError::Validation(ref cause) => cause,
ModifyDBInstanceError::Credentials(ref err) => err.description(),
ModifyDBInstanceError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
ModifyDBInstanceError::ParseError(ref cause) => cause,
ModifyDBInstanceError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ModifyDBParameterGroupError {
DBParameterGroupNotFoundFault(String),
InvalidDBParameterGroupStateFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ModifyDBParameterGroupError {
pub fn from_response(res: BufferedHttpResponse) -> ModifyDBParameterGroupError {
{
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[..] {
"DBParameterGroupNotFound" => {
return ModifyDBParameterGroupError::DBParameterGroupNotFoundFault(
String::from(parsed_error.message),
);
}
"InvalidDBParameterGroupState" => {
return ModifyDBParameterGroupError::InvalidDBParameterGroupStateFault(
String::from(parsed_error.message),
);
}
_ => {}
}
}
}
ModifyDBParameterGroupError::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 ModifyDBParameterGroupError {
fn from(err: XmlParseError) -> ModifyDBParameterGroupError {
let XmlParseError(message) = err;
ModifyDBParameterGroupError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for ModifyDBParameterGroupError {
fn from(err: CredentialsError) -> ModifyDBParameterGroupError {
ModifyDBParameterGroupError::Credentials(err)
}
}
impl From<HttpDispatchError> for ModifyDBParameterGroupError {
fn from(err: HttpDispatchError) -> ModifyDBParameterGroupError {
ModifyDBParameterGroupError::HttpDispatch(err)
}
}
impl From<io::Error> for ModifyDBParameterGroupError {
fn from(err: io::Error) -> ModifyDBParameterGroupError {
ModifyDBParameterGroupError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ModifyDBParameterGroupError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ModifyDBParameterGroupError {
fn description(&self) -> &str {
match *self {
ModifyDBParameterGroupError::DBParameterGroupNotFoundFault(ref cause) => cause,
ModifyDBParameterGroupError::InvalidDBParameterGroupStateFault(ref cause) => cause,
ModifyDBParameterGroupError::Validation(ref cause) => cause,
ModifyDBParameterGroupError::Credentials(ref err) => err.description(),
ModifyDBParameterGroupError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
ModifyDBParameterGroupError::ParseError(ref cause) => cause,
ModifyDBParameterGroupError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ModifyDBSubnetGroupError {
DBSubnetGroupDoesNotCoverEnoughAZs(String),
DBSubnetGroupNotFoundFault(String),
DBSubnetQuotaExceededFault(String),
InvalidSubnet(String),
SubnetAlreadyInUse(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ModifyDBSubnetGroupError {
pub fn from_response(res: BufferedHttpResponse) -> ModifyDBSubnetGroupError {
{
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[..] {
"DBSubnetGroupDoesNotCoverEnoughAZs" => {
return ModifyDBSubnetGroupError::DBSubnetGroupDoesNotCoverEnoughAZs(
String::from(parsed_error.message),
);
}
"DBSubnetGroupNotFoundFault" => {
return ModifyDBSubnetGroupError::DBSubnetGroupNotFoundFault(String::from(
parsed_error.message,
));
}
"DBSubnetQuotaExceededFault" => {
return ModifyDBSubnetGroupError::DBSubnetQuotaExceededFault(String::from(
parsed_error.message,
));
}
"InvalidSubnet" => {
return ModifyDBSubnetGroupError::InvalidSubnet(String::from(
parsed_error.message,
));
}
"SubnetAlreadyInUse" => {
return ModifyDBSubnetGroupError::SubnetAlreadyInUse(String::from(
parsed_error.message,
));
}
_ => {}
}
}
}
ModifyDBSubnetGroupError::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 ModifyDBSubnetGroupError {
fn from(err: XmlParseError) -> ModifyDBSubnetGroupError {
let XmlParseError(message) = err;
ModifyDBSubnetGroupError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for ModifyDBSubnetGroupError {
fn from(err: CredentialsError) -> ModifyDBSubnetGroupError {
ModifyDBSubnetGroupError::Credentials(err)
}
}
impl From<HttpDispatchError> for ModifyDBSubnetGroupError {
fn from(err: HttpDispatchError) -> ModifyDBSubnetGroupError {
ModifyDBSubnetGroupError::HttpDispatch(err)
}
}
impl From<io::Error> for ModifyDBSubnetGroupError {
fn from(err: io::Error) -> ModifyDBSubnetGroupError {
ModifyDBSubnetGroupError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ModifyDBSubnetGroupError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ModifyDBSubnetGroupError {
fn description(&self) -> &str {
match *self {
ModifyDBSubnetGroupError::DBSubnetGroupDoesNotCoverEnoughAZs(ref cause) => cause,
ModifyDBSubnetGroupError::DBSubnetGroupNotFoundFault(ref cause) => cause,
ModifyDBSubnetGroupError::DBSubnetQuotaExceededFault(ref cause) => cause,
ModifyDBSubnetGroupError::InvalidSubnet(ref cause) => cause,
ModifyDBSubnetGroupError::SubnetAlreadyInUse(ref cause) => cause,
ModifyDBSubnetGroupError::Validation(ref cause) => cause,
ModifyDBSubnetGroupError::Credentials(ref err) => err.description(),
ModifyDBSubnetGroupError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
ModifyDBSubnetGroupError::ParseError(ref cause) => cause,
ModifyDBSubnetGroupError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ModifyEventSubscriptionError {
EventSubscriptionQuotaExceededFault(String),
SNSInvalidTopicFault(String),
SNSNoAuthorizationFault(String),
SNSTopicArnNotFoundFault(String),
SubscriptionCategoryNotFoundFault(String),
SubscriptionNotFoundFault(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[..] {
"EventSubscriptionQuotaExceeded" => {
return ModifyEventSubscriptionError::EventSubscriptionQuotaExceededFault(
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,
));
}
"SubscriptionCategoryNotFound" => {
return ModifyEventSubscriptionError::SubscriptionCategoryNotFoundFault(
String::from(parsed_error.message),
);
}
"SubscriptionNotFound" => {
return ModifyEventSubscriptionError::SubscriptionNotFoundFault(
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::EventSubscriptionQuotaExceededFault(ref cause) => cause,
ModifyEventSubscriptionError::SNSInvalidTopicFault(ref cause) => cause,
ModifyEventSubscriptionError::SNSNoAuthorizationFault(ref cause) => cause,
ModifyEventSubscriptionError::SNSTopicArnNotFoundFault(ref cause) => cause,
ModifyEventSubscriptionError::SubscriptionCategoryNotFoundFault(ref cause) => cause,
ModifyEventSubscriptionError::SubscriptionNotFoundFault(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 PromoteReadReplicaDBClusterError {
DBClusterNotFoundFault(String),
InvalidDBClusterStateFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl PromoteReadReplicaDBClusterError {
pub fn from_response(res: BufferedHttpResponse) -> PromoteReadReplicaDBClusterError {
{
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[..] {
"DBClusterNotFoundFault" => {
return PromoteReadReplicaDBClusterError::DBClusterNotFoundFault(
String::from(parsed_error.message),
);
}
"InvalidDBClusterStateFault" => {
return PromoteReadReplicaDBClusterError::InvalidDBClusterStateFault(
String::from(parsed_error.message),
);
}
_ => {}
}
}
}
PromoteReadReplicaDBClusterError::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 PromoteReadReplicaDBClusterError {
fn from(err: XmlParseError) -> PromoteReadReplicaDBClusterError {
let XmlParseError(message) = err;
PromoteReadReplicaDBClusterError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for PromoteReadReplicaDBClusterError {
fn from(err: CredentialsError) -> PromoteReadReplicaDBClusterError {
PromoteReadReplicaDBClusterError::Credentials(err)
}
}
impl From<HttpDispatchError> for PromoteReadReplicaDBClusterError {
fn from(err: HttpDispatchError) -> PromoteReadReplicaDBClusterError {
PromoteReadReplicaDBClusterError::HttpDispatch(err)
}
}
impl From<io::Error> for PromoteReadReplicaDBClusterError {
fn from(err: io::Error) -> PromoteReadReplicaDBClusterError {
PromoteReadReplicaDBClusterError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for PromoteReadReplicaDBClusterError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for PromoteReadReplicaDBClusterError {
fn description(&self) -> &str {
match *self {
PromoteReadReplicaDBClusterError::DBClusterNotFoundFault(ref cause) => cause,
PromoteReadReplicaDBClusterError::InvalidDBClusterStateFault(ref cause) => cause,
PromoteReadReplicaDBClusterError::Validation(ref cause) => cause,
PromoteReadReplicaDBClusterError::Credentials(ref err) => err.description(),
PromoteReadReplicaDBClusterError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
PromoteReadReplicaDBClusterError::ParseError(ref cause) => cause,
PromoteReadReplicaDBClusterError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum RebootDBInstanceError {
DBInstanceNotFoundFault(String),
InvalidDBInstanceStateFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl RebootDBInstanceError {
pub fn from_response(res: BufferedHttpResponse) -> RebootDBInstanceError {
{
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[..] {
"DBInstanceNotFound" => {
return RebootDBInstanceError::DBInstanceNotFoundFault(String::from(
parsed_error.message,
));
}
"InvalidDBInstanceState" => {
return RebootDBInstanceError::InvalidDBInstanceStateFault(String::from(
parsed_error.message,
));
}
_ => {}
}
}
}
RebootDBInstanceError::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 RebootDBInstanceError {
fn from(err: XmlParseError) -> RebootDBInstanceError {
let XmlParseError(message) = err;
RebootDBInstanceError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for RebootDBInstanceError {
fn from(err: CredentialsError) -> RebootDBInstanceError {
RebootDBInstanceError::Credentials(err)
}
}
impl From<HttpDispatchError> for RebootDBInstanceError {
fn from(err: HttpDispatchError) -> RebootDBInstanceError {
RebootDBInstanceError::HttpDispatch(err)
}
}
impl From<io::Error> for RebootDBInstanceError {
fn from(err: io::Error) -> RebootDBInstanceError {
RebootDBInstanceError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for RebootDBInstanceError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for RebootDBInstanceError {
fn description(&self) -> &str {
match *self {
RebootDBInstanceError::DBInstanceNotFoundFault(ref cause) => cause,
RebootDBInstanceError::InvalidDBInstanceStateFault(ref cause) => cause,
RebootDBInstanceError::Validation(ref cause) => cause,
RebootDBInstanceError::Credentials(ref err) => err.description(),
RebootDBInstanceError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
RebootDBInstanceError::ParseError(ref cause) => cause,
RebootDBInstanceError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum RemoveRoleFromDBClusterError {
DBClusterNotFoundFault(String),
DBClusterRoleNotFoundFault(String),
InvalidDBClusterStateFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl RemoveRoleFromDBClusterError {
pub fn from_response(res: BufferedHttpResponse) -> RemoveRoleFromDBClusterError {
{
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[..] {
"DBClusterNotFoundFault" => {
return RemoveRoleFromDBClusterError::DBClusterNotFoundFault(String::from(
parsed_error.message,
));
}
"DBClusterRoleNotFound" => {
return RemoveRoleFromDBClusterError::DBClusterRoleNotFoundFault(
String::from(parsed_error.message),
);
}
"InvalidDBClusterStateFault" => {
return RemoveRoleFromDBClusterError::InvalidDBClusterStateFault(
String::from(parsed_error.message),
);
}
_ => {}
}
}
}
RemoveRoleFromDBClusterError::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 RemoveRoleFromDBClusterError {
fn from(err: XmlParseError) -> RemoveRoleFromDBClusterError {
let XmlParseError(message) = err;
RemoveRoleFromDBClusterError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for RemoveRoleFromDBClusterError {
fn from(err: CredentialsError) -> RemoveRoleFromDBClusterError {
RemoveRoleFromDBClusterError::Credentials(err)
}
}
impl From<HttpDispatchError> for RemoveRoleFromDBClusterError {
fn from(err: HttpDispatchError) -> RemoveRoleFromDBClusterError {
RemoveRoleFromDBClusterError::HttpDispatch(err)
}
}
impl From<io::Error> for RemoveRoleFromDBClusterError {
fn from(err: io::Error) -> RemoveRoleFromDBClusterError {
RemoveRoleFromDBClusterError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for RemoveRoleFromDBClusterError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for RemoveRoleFromDBClusterError {
fn description(&self) -> &str {
match *self {
RemoveRoleFromDBClusterError::DBClusterNotFoundFault(ref cause) => cause,
RemoveRoleFromDBClusterError::DBClusterRoleNotFoundFault(ref cause) => cause,
RemoveRoleFromDBClusterError::InvalidDBClusterStateFault(ref cause) => cause,
RemoveRoleFromDBClusterError::Validation(ref cause) => cause,
RemoveRoleFromDBClusterError::Credentials(ref err) => err.description(),
RemoveRoleFromDBClusterError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
RemoveRoleFromDBClusterError::ParseError(ref cause) => cause,
RemoveRoleFromDBClusterError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum RemoveSourceIdentifierFromSubscriptionError {
SourceNotFoundFault(String),
SubscriptionNotFoundFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl RemoveSourceIdentifierFromSubscriptionError {
pub fn from_response(res: BufferedHttpResponse) -> RemoveSourceIdentifierFromSubscriptionError {
{
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[..] {
"SourceNotFound" => return RemoveSourceIdentifierFromSubscriptionError::SourceNotFoundFault(String::from(parsed_error.message)),"SubscriptionNotFound" => return RemoveSourceIdentifierFromSubscriptionError::SubscriptionNotFoundFault(String::from(parsed_error.message)),_ => {}
}
}
}
RemoveSourceIdentifierFromSubscriptionError::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 RemoveSourceIdentifierFromSubscriptionError {
fn from(err: XmlParseError) -> RemoveSourceIdentifierFromSubscriptionError {
let XmlParseError(message) = err;
RemoveSourceIdentifierFromSubscriptionError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for RemoveSourceIdentifierFromSubscriptionError {
fn from(err: CredentialsError) -> RemoveSourceIdentifierFromSubscriptionError {
RemoveSourceIdentifierFromSubscriptionError::Credentials(err)
}
}
impl From<HttpDispatchError> for RemoveSourceIdentifierFromSubscriptionError {
fn from(err: HttpDispatchError) -> RemoveSourceIdentifierFromSubscriptionError {
RemoveSourceIdentifierFromSubscriptionError::HttpDispatch(err)
}
}
impl From<io::Error> for RemoveSourceIdentifierFromSubscriptionError {
fn from(err: io::Error) -> RemoveSourceIdentifierFromSubscriptionError {
RemoveSourceIdentifierFromSubscriptionError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for RemoveSourceIdentifierFromSubscriptionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for RemoveSourceIdentifierFromSubscriptionError {
fn description(&self) -> &str {
match *self {
RemoveSourceIdentifierFromSubscriptionError::SourceNotFoundFault(ref cause) => cause,
RemoveSourceIdentifierFromSubscriptionError::SubscriptionNotFoundFault(ref cause) => {
cause
}
RemoveSourceIdentifierFromSubscriptionError::Validation(ref cause) => cause,
RemoveSourceIdentifierFromSubscriptionError::Credentials(ref err) => err.description(),
RemoveSourceIdentifierFromSubscriptionError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
RemoveSourceIdentifierFromSubscriptionError::ParseError(ref cause) => cause,
RemoveSourceIdentifierFromSubscriptionError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum RemoveTagsFromResourceError {
DBClusterNotFoundFault(String),
DBInstanceNotFoundFault(String),
DBSnapshotNotFoundFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl RemoveTagsFromResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RemoveTagsFromResourceError {
{
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[..] {
"DBClusterNotFoundFault" => {
return RemoveTagsFromResourceError::DBClusterNotFoundFault(String::from(
parsed_error.message,
));
}
"DBInstanceNotFound" => {
return RemoveTagsFromResourceError::DBInstanceNotFoundFault(String::from(
parsed_error.message,
));
}
"DBSnapshotNotFound" => {
return RemoveTagsFromResourceError::DBSnapshotNotFoundFault(String::from(
parsed_error.message,
));
}
_ => {}
}
}
}
RemoveTagsFromResourceError::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 RemoveTagsFromResourceError {
fn from(err: XmlParseError) -> RemoveTagsFromResourceError {
let XmlParseError(message) = err;
RemoveTagsFromResourceError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for RemoveTagsFromResourceError {
fn from(err: CredentialsError) -> RemoveTagsFromResourceError {
RemoveTagsFromResourceError::Credentials(err)
}
}
impl From<HttpDispatchError> for RemoveTagsFromResourceError {
fn from(err: HttpDispatchError) -> RemoveTagsFromResourceError {
RemoveTagsFromResourceError::HttpDispatch(err)
}
}
impl From<io::Error> for RemoveTagsFromResourceError {
fn from(err: io::Error) -> RemoveTagsFromResourceError {
RemoveTagsFromResourceError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for RemoveTagsFromResourceError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for RemoveTagsFromResourceError {
fn description(&self) -> &str {
match *self {
RemoveTagsFromResourceError::DBClusterNotFoundFault(ref cause) => cause,
RemoveTagsFromResourceError::DBInstanceNotFoundFault(ref cause) => cause,
RemoveTagsFromResourceError::DBSnapshotNotFoundFault(ref cause) => cause,
RemoveTagsFromResourceError::Validation(ref cause) => cause,
RemoveTagsFromResourceError::Credentials(ref err) => err.description(),
RemoveTagsFromResourceError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
RemoveTagsFromResourceError::ParseError(ref cause) => cause,
RemoveTagsFromResourceError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ResetDBClusterParameterGroupError {
DBParameterGroupNotFoundFault(String),
InvalidDBParameterGroupStateFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ResetDBClusterParameterGroupError {
pub fn from_response(res: BufferedHttpResponse) -> ResetDBClusterParameterGroupError {
{
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[..] {
"DBParameterGroupNotFound" => {
return ResetDBClusterParameterGroupError::DBParameterGroupNotFoundFault(
String::from(parsed_error.message),
);
}
"InvalidDBParameterGroupState" => {
return ResetDBClusterParameterGroupError::InvalidDBParameterGroupStateFault(
String::from(parsed_error.message),
);
}
_ => {}
}
}
}
ResetDBClusterParameterGroupError::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 ResetDBClusterParameterGroupError {
fn from(err: XmlParseError) -> ResetDBClusterParameterGroupError {
let XmlParseError(message) = err;
ResetDBClusterParameterGroupError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for ResetDBClusterParameterGroupError {
fn from(err: CredentialsError) -> ResetDBClusterParameterGroupError {
ResetDBClusterParameterGroupError::Credentials(err)
}
}
impl From<HttpDispatchError> for ResetDBClusterParameterGroupError {
fn from(err: HttpDispatchError) -> ResetDBClusterParameterGroupError {
ResetDBClusterParameterGroupError::HttpDispatch(err)
}
}
impl From<io::Error> for ResetDBClusterParameterGroupError {
fn from(err: io::Error) -> ResetDBClusterParameterGroupError {
ResetDBClusterParameterGroupError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ResetDBClusterParameterGroupError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ResetDBClusterParameterGroupError {
fn description(&self) -> &str {
match *self {
ResetDBClusterParameterGroupError::DBParameterGroupNotFoundFault(ref cause) => cause,
ResetDBClusterParameterGroupError::InvalidDBParameterGroupStateFault(ref cause) => {
cause
}
ResetDBClusterParameterGroupError::Validation(ref cause) => cause,
ResetDBClusterParameterGroupError::Credentials(ref err) => err.description(),
ResetDBClusterParameterGroupError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
ResetDBClusterParameterGroupError::ParseError(ref cause) => cause,
ResetDBClusterParameterGroupError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ResetDBParameterGroupError {
DBParameterGroupNotFoundFault(String),
InvalidDBParameterGroupStateFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ResetDBParameterGroupError {
pub fn from_response(res: BufferedHttpResponse) -> ResetDBParameterGroupError {
{
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[..] {
"DBParameterGroupNotFound" => {
return ResetDBParameterGroupError::DBParameterGroupNotFoundFault(
String::from(parsed_error.message),
);
}
"InvalidDBParameterGroupState" => {
return ResetDBParameterGroupError::InvalidDBParameterGroupStateFault(
String::from(parsed_error.message),
);
}
_ => {}
}
}
}
ResetDBParameterGroupError::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 ResetDBParameterGroupError {
fn from(err: XmlParseError) -> ResetDBParameterGroupError {
let XmlParseError(message) = err;
ResetDBParameterGroupError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for ResetDBParameterGroupError {
fn from(err: CredentialsError) -> ResetDBParameterGroupError {
ResetDBParameterGroupError::Credentials(err)
}
}
impl From<HttpDispatchError> for ResetDBParameterGroupError {
fn from(err: HttpDispatchError) -> ResetDBParameterGroupError {
ResetDBParameterGroupError::HttpDispatch(err)
}
}
impl From<io::Error> for ResetDBParameterGroupError {
fn from(err: io::Error) -> ResetDBParameterGroupError {
ResetDBParameterGroupError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ResetDBParameterGroupError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ResetDBParameterGroupError {
fn description(&self) -> &str {
match *self {
ResetDBParameterGroupError::DBParameterGroupNotFoundFault(ref cause) => cause,
ResetDBParameterGroupError::InvalidDBParameterGroupStateFault(ref cause) => cause,
ResetDBParameterGroupError::Validation(ref cause) => cause,
ResetDBParameterGroupError::Credentials(ref err) => err.description(),
ResetDBParameterGroupError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
ResetDBParameterGroupError::ParseError(ref cause) => cause,
ResetDBParameterGroupError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum RestoreDBClusterFromSnapshotError {
DBClusterAlreadyExistsFault(String),
DBClusterQuotaExceededFault(String),
DBClusterSnapshotNotFoundFault(String),
DBSnapshotNotFoundFault(String),
DBSubnetGroupNotFoundFault(String),
InsufficientDBClusterCapacityFault(String),
InsufficientStorageClusterCapacityFault(String),
InvalidDBClusterSnapshotStateFault(String),
InvalidDBSnapshotStateFault(String),
InvalidRestoreFault(String),
InvalidSubnet(String),
InvalidVPCNetworkStateFault(String),
KMSKeyNotAccessibleFault(String),
OptionGroupNotFoundFault(String),
StorageQuotaExceededFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl RestoreDBClusterFromSnapshotError {
pub fn from_response(res: BufferedHttpResponse) -> RestoreDBClusterFromSnapshotError {
{
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[..] {
"DBClusterAlreadyExistsFault" => return RestoreDBClusterFromSnapshotError::DBClusterAlreadyExistsFault(String::from(parsed_error.message)),"DBClusterQuotaExceededFault" => return RestoreDBClusterFromSnapshotError::DBClusterQuotaExceededFault(String::from(parsed_error.message)),"DBClusterSnapshotNotFoundFault" => return RestoreDBClusterFromSnapshotError::DBClusterSnapshotNotFoundFault(String::from(parsed_error.message)),"DBSnapshotNotFound" => return RestoreDBClusterFromSnapshotError::DBSnapshotNotFoundFault(String::from(parsed_error.message)),"DBSubnetGroupNotFoundFault" => return RestoreDBClusterFromSnapshotError::DBSubnetGroupNotFoundFault(String::from(parsed_error.message)),"InsufficientDBClusterCapacityFault" => return RestoreDBClusterFromSnapshotError::InsufficientDBClusterCapacityFault(String::from(parsed_error.message)),"InsufficientStorageClusterCapacity" => return RestoreDBClusterFromSnapshotError::InsufficientStorageClusterCapacityFault(String::from(parsed_error.message)),"InvalidDBClusterSnapshotStateFault" => return RestoreDBClusterFromSnapshotError::InvalidDBClusterSnapshotStateFault(String::from(parsed_error.message)),"InvalidDBSnapshotState" => return RestoreDBClusterFromSnapshotError::InvalidDBSnapshotStateFault(String::from(parsed_error.message)),"InvalidRestoreFault" => return RestoreDBClusterFromSnapshotError::InvalidRestoreFault(String::from(parsed_error.message)),"InvalidSubnet" => return RestoreDBClusterFromSnapshotError::InvalidSubnet(String::from(parsed_error.message)),"InvalidVPCNetworkStateFault" => return RestoreDBClusterFromSnapshotError::InvalidVPCNetworkStateFault(String::from(parsed_error.message)),"KMSKeyNotAccessibleFault" => return RestoreDBClusterFromSnapshotError::KMSKeyNotAccessibleFault(String::from(parsed_error.message)),"OptionGroupNotFoundFault" => return RestoreDBClusterFromSnapshotError::OptionGroupNotFoundFault(String::from(parsed_error.message)),"StorageQuotaExceeded" => return RestoreDBClusterFromSnapshotError::StorageQuotaExceededFault(String::from(parsed_error.message)),_ => {}
}
}
}
RestoreDBClusterFromSnapshotError::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 RestoreDBClusterFromSnapshotError {
fn from(err: XmlParseError) -> RestoreDBClusterFromSnapshotError {
let XmlParseError(message) = err;
RestoreDBClusterFromSnapshotError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for RestoreDBClusterFromSnapshotError {
fn from(err: CredentialsError) -> RestoreDBClusterFromSnapshotError {
RestoreDBClusterFromSnapshotError::Credentials(err)
}
}
impl From<HttpDispatchError> for RestoreDBClusterFromSnapshotError {
fn from(err: HttpDispatchError) -> RestoreDBClusterFromSnapshotError {
RestoreDBClusterFromSnapshotError::HttpDispatch(err)
}
}
impl From<io::Error> for RestoreDBClusterFromSnapshotError {
fn from(err: io::Error) -> RestoreDBClusterFromSnapshotError {
RestoreDBClusterFromSnapshotError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for RestoreDBClusterFromSnapshotError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for RestoreDBClusterFromSnapshotError {
fn description(&self) -> &str {
match *self {
RestoreDBClusterFromSnapshotError::DBClusterAlreadyExistsFault(ref cause) => cause,
RestoreDBClusterFromSnapshotError::DBClusterQuotaExceededFault(ref cause) => cause,
RestoreDBClusterFromSnapshotError::DBClusterSnapshotNotFoundFault(ref cause) => cause,
RestoreDBClusterFromSnapshotError::DBSnapshotNotFoundFault(ref cause) => cause,
RestoreDBClusterFromSnapshotError::DBSubnetGroupNotFoundFault(ref cause) => cause,
RestoreDBClusterFromSnapshotError::InsufficientDBClusterCapacityFault(ref cause) => {
cause
}
RestoreDBClusterFromSnapshotError::InsufficientStorageClusterCapacityFault(
ref cause,
) => cause,
RestoreDBClusterFromSnapshotError::InvalidDBClusterSnapshotStateFault(ref cause) => {
cause
}
RestoreDBClusterFromSnapshotError::InvalidDBSnapshotStateFault(ref cause) => cause,
RestoreDBClusterFromSnapshotError::InvalidRestoreFault(ref cause) => cause,
RestoreDBClusterFromSnapshotError::InvalidSubnet(ref cause) => cause,
RestoreDBClusterFromSnapshotError::InvalidVPCNetworkStateFault(ref cause) => cause,
RestoreDBClusterFromSnapshotError::KMSKeyNotAccessibleFault(ref cause) => cause,
RestoreDBClusterFromSnapshotError::OptionGroupNotFoundFault(ref cause) => cause,
RestoreDBClusterFromSnapshotError::StorageQuotaExceededFault(ref cause) => cause,
RestoreDBClusterFromSnapshotError::Validation(ref cause) => cause,
RestoreDBClusterFromSnapshotError::Credentials(ref err) => err.description(),
RestoreDBClusterFromSnapshotError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
RestoreDBClusterFromSnapshotError::ParseError(ref cause) => cause,
RestoreDBClusterFromSnapshotError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum RestoreDBClusterToPointInTimeError {
DBClusterAlreadyExistsFault(String),
DBClusterNotFoundFault(String),
DBClusterQuotaExceededFault(String),
DBClusterSnapshotNotFoundFault(String),
DBSubnetGroupNotFoundFault(String),
InsufficientDBClusterCapacityFault(String),
InsufficientStorageClusterCapacityFault(String),
InvalidDBClusterSnapshotStateFault(String),
InvalidDBClusterStateFault(String),
InvalidDBSnapshotStateFault(String),
InvalidRestoreFault(String),
InvalidSubnet(String),
InvalidVPCNetworkStateFault(String),
KMSKeyNotAccessibleFault(String),
OptionGroupNotFoundFault(String),
StorageQuotaExceededFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl RestoreDBClusterToPointInTimeError {
pub fn from_response(res: BufferedHttpResponse) -> RestoreDBClusterToPointInTimeError {
{
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[..] {
"DBClusterAlreadyExistsFault" => return RestoreDBClusterToPointInTimeError::DBClusterAlreadyExistsFault(String::from(parsed_error.message)),"DBClusterNotFoundFault" => return RestoreDBClusterToPointInTimeError::DBClusterNotFoundFault(String::from(parsed_error.message)),"DBClusterQuotaExceededFault" => return RestoreDBClusterToPointInTimeError::DBClusterQuotaExceededFault(String::from(parsed_error.message)),"DBClusterSnapshotNotFoundFault" => return RestoreDBClusterToPointInTimeError::DBClusterSnapshotNotFoundFault(String::from(parsed_error.message)),"DBSubnetGroupNotFoundFault" => return RestoreDBClusterToPointInTimeError::DBSubnetGroupNotFoundFault(String::from(parsed_error.message)),"InsufficientDBClusterCapacityFault" => return RestoreDBClusterToPointInTimeError::InsufficientDBClusterCapacityFault(String::from(parsed_error.message)),"InsufficientStorageClusterCapacity" => return RestoreDBClusterToPointInTimeError::InsufficientStorageClusterCapacityFault(String::from(parsed_error.message)),"InvalidDBClusterSnapshotStateFault" => return RestoreDBClusterToPointInTimeError::InvalidDBClusterSnapshotStateFault(String::from(parsed_error.message)),"InvalidDBClusterStateFault" => return RestoreDBClusterToPointInTimeError::InvalidDBClusterStateFault(String::from(parsed_error.message)),"InvalidDBSnapshotState" => return RestoreDBClusterToPointInTimeError::InvalidDBSnapshotStateFault(String::from(parsed_error.message)),"InvalidRestoreFault" => return RestoreDBClusterToPointInTimeError::InvalidRestoreFault(String::from(parsed_error.message)),"InvalidSubnet" => return RestoreDBClusterToPointInTimeError::InvalidSubnet(String::from(parsed_error.message)),"InvalidVPCNetworkStateFault" => return RestoreDBClusterToPointInTimeError::InvalidVPCNetworkStateFault(String::from(parsed_error.message)),"KMSKeyNotAccessibleFault" => return RestoreDBClusterToPointInTimeError::KMSKeyNotAccessibleFault(String::from(parsed_error.message)),"OptionGroupNotFoundFault" => return RestoreDBClusterToPointInTimeError::OptionGroupNotFoundFault(String::from(parsed_error.message)),"StorageQuotaExceeded" => return RestoreDBClusterToPointInTimeError::StorageQuotaExceededFault(String::from(parsed_error.message)),_ => {}
}
}
}
RestoreDBClusterToPointInTimeError::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 RestoreDBClusterToPointInTimeError {
fn from(err: XmlParseError) -> RestoreDBClusterToPointInTimeError {
let XmlParseError(message) = err;
RestoreDBClusterToPointInTimeError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for RestoreDBClusterToPointInTimeError {
fn from(err: CredentialsError) -> RestoreDBClusterToPointInTimeError {
RestoreDBClusterToPointInTimeError::Credentials(err)
}
}
impl From<HttpDispatchError> for RestoreDBClusterToPointInTimeError {
fn from(err: HttpDispatchError) -> RestoreDBClusterToPointInTimeError {
RestoreDBClusterToPointInTimeError::HttpDispatch(err)
}
}
impl From<io::Error> for RestoreDBClusterToPointInTimeError {
fn from(err: io::Error) -> RestoreDBClusterToPointInTimeError {
RestoreDBClusterToPointInTimeError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for RestoreDBClusterToPointInTimeError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for RestoreDBClusterToPointInTimeError {
fn description(&self) -> &str {
match *self {
RestoreDBClusterToPointInTimeError::DBClusterAlreadyExistsFault(ref cause) => cause,
RestoreDBClusterToPointInTimeError::DBClusterNotFoundFault(ref cause) => cause,
RestoreDBClusterToPointInTimeError::DBClusterQuotaExceededFault(ref cause) => cause,
RestoreDBClusterToPointInTimeError::DBClusterSnapshotNotFoundFault(ref cause) => cause,
RestoreDBClusterToPointInTimeError::DBSubnetGroupNotFoundFault(ref cause) => cause,
RestoreDBClusterToPointInTimeError::InsufficientDBClusterCapacityFault(ref cause) => {
cause
}
RestoreDBClusterToPointInTimeError::InsufficientStorageClusterCapacityFault(
ref cause,
) => cause,
RestoreDBClusterToPointInTimeError::InvalidDBClusterSnapshotStateFault(ref cause) => {
cause
}
RestoreDBClusterToPointInTimeError::InvalidDBClusterStateFault(ref cause) => cause,
RestoreDBClusterToPointInTimeError::InvalidDBSnapshotStateFault(ref cause) => cause,
RestoreDBClusterToPointInTimeError::InvalidRestoreFault(ref cause) => cause,
RestoreDBClusterToPointInTimeError::InvalidSubnet(ref cause) => cause,
RestoreDBClusterToPointInTimeError::InvalidVPCNetworkStateFault(ref cause) => cause,
RestoreDBClusterToPointInTimeError::KMSKeyNotAccessibleFault(ref cause) => cause,
RestoreDBClusterToPointInTimeError::OptionGroupNotFoundFault(ref cause) => cause,
RestoreDBClusterToPointInTimeError::StorageQuotaExceededFault(ref cause) => cause,
RestoreDBClusterToPointInTimeError::Validation(ref cause) => cause,
RestoreDBClusterToPointInTimeError::Credentials(ref err) => err.description(),
RestoreDBClusterToPointInTimeError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
RestoreDBClusterToPointInTimeError::ParseError(ref cause) => cause,
RestoreDBClusterToPointInTimeError::Unknown(_) => "unknown error",
}
}
}
pub trait Neptune {
fn add_role_to_db_cluster(
&self,
input: AddRoleToDBClusterMessage,
) -> RusotoFuture<(), AddRoleToDBClusterError>;
fn add_source_identifier_to_subscription(
&self,
input: AddSourceIdentifierToSubscriptionMessage,
) -> RusotoFuture<AddSourceIdentifierToSubscriptionResult, AddSourceIdentifierToSubscriptionError>;
fn add_tags_to_resource(
&self,
input: AddTagsToResourceMessage,
) -> RusotoFuture<(), AddTagsToResourceError>;
fn apply_pending_maintenance_action(
&self,
input: ApplyPendingMaintenanceActionMessage,
) -> RusotoFuture<ApplyPendingMaintenanceActionResult, ApplyPendingMaintenanceActionError>;
fn copy_db_cluster_parameter_group(
&self,
input: CopyDBClusterParameterGroupMessage,
) -> RusotoFuture<CopyDBClusterParameterGroupResult, CopyDBClusterParameterGroupError>;
fn copy_db_cluster_snapshot(
&self,
input: CopyDBClusterSnapshotMessage,
) -> RusotoFuture<CopyDBClusterSnapshotResult, CopyDBClusterSnapshotError>;
fn copy_db_parameter_group(
&self,
input: CopyDBParameterGroupMessage,
) -> RusotoFuture<CopyDBParameterGroupResult, CopyDBParameterGroupError>;
fn create_db_cluster(
&self,
input: CreateDBClusterMessage,
) -> RusotoFuture<CreateDBClusterResult, CreateDBClusterError>;
fn create_db_cluster_parameter_group(
&self,
input: CreateDBClusterParameterGroupMessage,
) -> RusotoFuture<CreateDBClusterParameterGroupResult, CreateDBClusterParameterGroupError>;
fn create_db_cluster_snapshot(
&self,
input: CreateDBClusterSnapshotMessage,
) -> RusotoFuture<CreateDBClusterSnapshotResult, CreateDBClusterSnapshotError>;
fn create_db_instance(
&self,
input: CreateDBInstanceMessage,
) -> RusotoFuture<CreateDBInstanceResult, CreateDBInstanceError>;
fn create_db_parameter_group(
&self,
input: CreateDBParameterGroupMessage,
) -> RusotoFuture<CreateDBParameterGroupResult, CreateDBParameterGroupError>;
fn create_db_subnet_group(
&self,
input: CreateDBSubnetGroupMessage,
) -> RusotoFuture<CreateDBSubnetGroupResult, CreateDBSubnetGroupError>;
fn create_event_subscription(
&self,
input: CreateEventSubscriptionMessage,
) -> RusotoFuture<CreateEventSubscriptionResult, CreateEventSubscriptionError>;
fn delete_db_cluster(
&self,
input: DeleteDBClusterMessage,
) -> RusotoFuture<DeleteDBClusterResult, DeleteDBClusterError>;
fn delete_db_cluster_parameter_group(
&self,
input: DeleteDBClusterParameterGroupMessage,
) -> RusotoFuture<(), DeleteDBClusterParameterGroupError>;
fn delete_db_cluster_snapshot(
&self,
input: DeleteDBClusterSnapshotMessage,
) -> RusotoFuture<DeleteDBClusterSnapshotResult, DeleteDBClusterSnapshotError>;
fn delete_db_instance(
&self,
input: DeleteDBInstanceMessage,
) -> RusotoFuture<DeleteDBInstanceResult, DeleteDBInstanceError>;
fn delete_db_parameter_group(
&self,
input: DeleteDBParameterGroupMessage,
) -> RusotoFuture<(), DeleteDBParameterGroupError>;
fn delete_db_subnet_group(
&self,
input: DeleteDBSubnetGroupMessage,
) -> RusotoFuture<(), DeleteDBSubnetGroupError>;
fn delete_event_subscription(
&self,
input: DeleteEventSubscriptionMessage,
) -> RusotoFuture<DeleteEventSubscriptionResult, DeleteEventSubscriptionError>;
fn describe_db_cluster_parameter_groups(
&self,
input: DescribeDBClusterParameterGroupsMessage,
) -> RusotoFuture<DBClusterParameterGroupsMessage, DescribeDBClusterParameterGroupsError>;
fn describe_db_cluster_parameters(
&self,
input: DescribeDBClusterParametersMessage,
) -> RusotoFuture<DBClusterParameterGroupDetails, DescribeDBClusterParametersError>;
fn describe_db_cluster_snapshot_attributes(
&self,
input: DescribeDBClusterSnapshotAttributesMessage,
) -> RusotoFuture<
DescribeDBClusterSnapshotAttributesResult,
DescribeDBClusterSnapshotAttributesError,
>;
fn describe_db_cluster_snapshots(
&self,
input: DescribeDBClusterSnapshotsMessage,
) -> RusotoFuture<DBClusterSnapshotMessage, DescribeDBClusterSnapshotsError>;
fn describe_db_clusters(
&self,
input: DescribeDBClustersMessage,
) -> RusotoFuture<DBClusterMessage, DescribeDBClustersError>;
fn describe_db_engine_versions(
&self,
input: DescribeDBEngineVersionsMessage,
) -> RusotoFuture<DBEngineVersionMessage, DescribeDBEngineVersionsError>;
fn describe_db_instances(
&self,
input: DescribeDBInstancesMessage,
) -> RusotoFuture<DBInstanceMessage, DescribeDBInstancesError>;
fn describe_db_parameter_groups(
&self,
input: DescribeDBParameterGroupsMessage,
) -> RusotoFuture<DBParameterGroupsMessage, DescribeDBParameterGroupsError>;
fn describe_db_parameters(
&self,
input: DescribeDBParametersMessage,
) -> RusotoFuture<DBParameterGroupDetails, DescribeDBParametersError>;
fn describe_db_subnet_groups(
&self,
input: DescribeDBSubnetGroupsMessage,
) -> RusotoFuture<DBSubnetGroupMessage, DescribeDBSubnetGroupsError>;
fn describe_engine_default_cluster_parameters(
&self,
input: DescribeEngineDefaultClusterParametersMessage,
) -> RusotoFuture<
DescribeEngineDefaultClusterParametersResult,
DescribeEngineDefaultClusterParametersError,
>;
fn describe_engine_default_parameters(
&self,
input: DescribeEngineDefaultParametersMessage,
) -> RusotoFuture<DescribeEngineDefaultParametersResult, DescribeEngineDefaultParametersError>;
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_orderable_db_instance_options(
&self,
input: DescribeOrderableDBInstanceOptionsMessage,
) -> RusotoFuture<OrderableDBInstanceOptionsMessage, DescribeOrderableDBInstanceOptionsError>;
fn describe_pending_maintenance_actions(
&self,
input: DescribePendingMaintenanceActionsMessage,
) -> RusotoFuture<PendingMaintenanceActionsMessage, DescribePendingMaintenanceActionsError>;
fn describe_valid_db_instance_modifications(
&self,
input: DescribeValidDBInstanceModificationsMessage,
) -> RusotoFuture<
DescribeValidDBInstanceModificationsResult,
DescribeValidDBInstanceModificationsError,
>;
fn failover_db_cluster(
&self,
input: FailoverDBClusterMessage,
) -> RusotoFuture<FailoverDBClusterResult, FailoverDBClusterError>;
fn list_tags_for_resource(
&self,
input: ListTagsForResourceMessage,
) -> RusotoFuture<TagListMessage, ListTagsForResourceError>;
fn modify_db_cluster(
&self,
input: ModifyDBClusterMessage,
) -> RusotoFuture<ModifyDBClusterResult, ModifyDBClusterError>;
fn modify_db_cluster_parameter_group(
&self,
input: ModifyDBClusterParameterGroupMessage,
) -> RusotoFuture<DBClusterParameterGroupNameMessage, ModifyDBClusterParameterGroupError>;
fn modify_db_cluster_snapshot_attribute(
&self,
input: ModifyDBClusterSnapshotAttributeMessage,
) -> RusotoFuture<ModifyDBClusterSnapshotAttributeResult, ModifyDBClusterSnapshotAttributeError>;
fn modify_db_instance(
&self,
input: ModifyDBInstanceMessage,
) -> RusotoFuture<ModifyDBInstanceResult, ModifyDBInstanceError>;
fn modify_db_parameter_group(
&self,
input: ModifyDBParameterGroupMessage,
) -> RusotoFuture<DBParameterGroupNameMessage, ModifyDBParameterGroupError>;
fn modify_db_subnet_group(
&self,
input: ModifyDBSubnetGroupMessage,
) -> RusotoFuture<ModifyDBSubnetGroupResult, ModifyDBSubnetGroupError>;
fn modify_event_subscription(
&self,
input: ModifyEventSubscriptionMessage,
) -> RusotoFuture<ModifyEventSubscriptionResult, ModifyEventSubscriptionError>;
fn promote_read_replica_db_cluster(
&self,
input: PromoteReadReplicaDBClusterMessage,
) -> RusotoFuture<PromoteReadReplicaDBClusterResult, PromoteReadReplicaDBClusterError>;
fn reboot_db_instance(
&self,
input: RebootDBInstanceMessage,
) -> RusotoFuture<RebootDBInstanceResult, RebootDBInstanceError>;
fn remove_role_from_db_cluster(
&self,
input: RemoveRoleFromDBClusterMessage,
) -> RusotoFuture<(), RemoveRoleFromDBClusterError>;
fn remove_source_identifier_from_subscription(
&self,
input: RemoveSourceIdentifierFromSubscriptionMessage,
) -> RusotoFuture<
RemoveSourceIdentifierFromSubscriptionResult,
RemoveSourceIdentifierFromSubscriptionError,
>;
fn remove_tags_from_resource(
&self,
input: RemoveTagsFromResourceMessage,
) -> RusotoFuture<(), RemoveTagsFromResourceError>;
fn reset_db_cluster_parameter_group(
&self,
input: ResetDBClusterParameterGroupMessage,
) -> RusotoFuture<DBClusterParameterGroupNameMessage, ResetDBClusterParameterGroupError>;
fn reset_db_parameter_group(
&self,
input: ResetDBParameterGroupMessage,
) -> RusotoFuture<DBParameterGroupNameMessage, ResetDBParameterGroupError>;
fn restore_db_cluster_from_snapshot(
&self,
input: RestoreDBClusterFromSnapshotMessage,
) -> RusotoFuture<RestoreDBClusterFromSnapshotResult, RestoreDBClusterFromSnapshotError>;
fn restore_db_cluster_to_point_in_time(
&self,
input: RestoreDBClusterToPointInTimeMessage,
) -> RusotoFuture<RestoreDBClusterToPointInTimeResult, RestoreDBClusterToPointInTimeError>;
}
#[derive(Clone)]
pub struct NeptuneClient {
client: Client,
region: region::Region,
}
impl NeptuneClient {
pub fn new(region: region::Region) -> NeptuneClient {
NeptuneClient {
client: Client::shared(),
region: region,
}
}
pub fn new_with<P, D>(
request_dispatcher: D,
credentials_provider: P,
region: region::Region,
) -> NeptuneClient
where
P: ProvideAwsCredentials + Send + Sync + 'static,
P::Future: Send,
D: DispatchSignedRequest + Send + Sync + 'static,
D::Future: Send,
{
NeptuneClient {
client: Client::new_with(credentials_provider, request_dispatcher),
region: region,
}
}
}
impl Neptune for NeptuneClient {
fn add_role_to_db_cluster(
&self,
input: AddRoleToDBClusterMessage,
) -> RusotoFuture<(), AddRoleToDBClusterError> {
let mut request = SignedRequest::new("POST", "rds", &self.region, "/");
let mut params = Params::new();
params.put("Action", "AddRoleToDBCluster");
params.put("Version", "2014-10-31");
AddRoleToDBClusterMessageSerializer::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(AddRoleToDBClusterError::from_response(response))),
);
}
Box::new(future::ok(::std::mem::drop(response)))
})
}
fn add_source_identifier_to_subscription(
&self,
input: AddSourceIdentifierToSubscriptionMessage,
) -> RusotoFuture<AddSourceIdentifierToSubscriptionResult, AddSourceIdentifierToSubscriptionError>
{
let mut request = SignedRequest::new("POST", "rds", &self.region, "/");
let mut params = Params::new();
params.put("Action", "AddSourceIdentifierToSubscription");
params.put("Version", "2014-10-31");
AddSourceIdentifierToSubscriptionMessageSerializer::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(AddSourceIdentifierToSubscriptionError::from_response(
response,
))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = AddSourceIdentifierToSubscriptionResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
start_element(&actual_tag_name, &mut stack)?;
result = AddSourceIdentifierToSubscriptionResultDeserializer::deserialize(
"AddSourceIdentifierToSubscriptionResult",
&mut stack,
)?;
skip_tree(&mut stack);
end_element(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn add_tags_to_resource(
&self,
input: AddTagsToResourceMessage,
) -> RusotoFuture<(), AddTagsToResourceError> {
let mut request = SignedRequest::new("POST", "rds", &self.region, "/");
let mut params = Params::new();
params.put("Action", "AddTagsToResource");
params.put("Version", "2014-10-31");
AddTagsToResourceMessageSerializer::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(AddTagsToResourceError::from_response(response))),
);
}
Box::new(future::ok(::std::mem::drop(response)))
})
}
fn apply_pending_maintenance_action(
&self,
input: ApplyPendingMaintenanceActionMessage,
) -> RusotoFuture<ApplyPendingMaintenanceActionResult, ApplyPendingMaintenanceActionError> {
let mut request = SignedRequest::new("POST", "rds", &self.region, "/");
let mut params = Params::new();
params.put("Action", "ApplyPendingMaintenanceAction");
params.put("Version", "2014-10-31");
ApplyPendingMaintenanceActionMessageSerializer::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(ApplyPendingMaintenanceActionError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = ApplyPendingMaintenanceActionResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
start_element(&actual_tag_name, &mut stack)?;
result = ApplyPendingMaintenanceActionResultDeserializer::deserialize(
"ApplyPendingMaintenanceActionResult",
&mut stack,
)?;
skip_tree(&mut stack);
end_element(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn copy_db_cluster_parameter_group(
&self,
input: CopyDBClusterParameterGroupMessage,
) -> RusotoFuture<CopyDBClusterParameterGroupResult, CopyDBClusterParameterGroupError> {
let mut request = SignedRequest::new("POST", "rds", &self.region, "/");
let mut params = Params::new();
params.put("Action", "CopyDBClusterParameterGroup");
params.put("Version", "2014-10-31");
CopyDBClusterParameterGroupMessageSerializer::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(CopyDBClusterParameterGroupError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = CopyDBClusterParameterGroupResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
start_element(&actual_tag_name, &mut stack)?;
result = CopyDBClusterParameterGroupResultDeserializer::deserialize(
"CopyDBClusterParameterGroupResult",
&mut stack,
)?;
skip_tree(&mut stack);
end_element(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn copy_db_cluster_snapshot(
&self,
input: CopyDBClusterSnapshotMessage,
) -> RusotoFuture<CopyDBClusterSnapshotResult, CopyDBClusterSnapshotError> {
let mut request = SignedRequest::new("POST", "rds", &self.region, "/");
let mut params = Params::new();
params.put("Action", "CopyDBClusterSnapshot");
params.put("Version", "2014-10-31");
CopyDBClusterSnapshotMessageSerializer::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(CopyDBClusterSnapshotError::from_response(response))
}),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = CopyDBClusterSnapshotResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
start_element(&actual_tag_name, &mut stack)?;
result = CopyDBClusterSnapshotResultDeserializer::deserialize(
"CopyDBClusterSnapshotResult",
&mut stack,
)?;
skip_tree(&mut stack);
end_element(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn copy_db_parameter_group(
&self,
input: CopyDBParameterGroupMessage,
) -> RusotoFuture<CopyDBParameterGroupResult, CopyDBParameterGroupError> {
let mut request = SignedRequest::new("POST", "rds", &self.region, "/");
let mut params = Params::new();
params.put("Action", "CopyDBParameterGroup");
params.put("Version", "2014-10-31");
CopyDBParameterGroupMessageSerializer::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(CopyDBParameterGroupError::from_response(response))
}),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = CopyDBParameterGroupResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
start_element(&actual_tag_name, &mut stack)?;
result = CopyDBParameterGroupResultDeserializer::deserialize(
"CopyDBParameterGroupResult",
&mut stack,
)?;
skip_tree(&mut stack);
end_element(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn create_db_cluster(
&self,
input: CreateDBClusterMessage,
) -> RusotoFuture<CreateDBClusterResult, CreateDBClusterError> {
let mut request = SignedRequest::new("POST", "rds", &self.region, "/");
let mut params = Params::new();
params.put("Action", "CreateDBCluster");
params.put("Version", "2014-10-31");
CreateDBClusterMessageSerializer::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(CreateDBClusterError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = CreateDBClusterResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
start_element(&actual_tag_name, &mut stack)?;
result = CreateDBClusterResultDeserializer::deserialize(
"CreateDBClusterResult",
&mut stack,
)?;
skip_tree(&mut stack);
end_element(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn create_db_cluster_parameter_group(
&self,
input: CreateDBClusterParameterGroupMessage,
) -> RusotoFuture<CreateDBClusterParameterGroupResult, CreateDBClusterParameterGroupError> {
let mut request = SignedRequest::new("POST", "rds", &self.region, "/");
let mut params = Params::new();
params.put("Action", "CreateDBClusterParameterGroup");
params.put("Version", "2014-10-31");
CreateDBClusterParameterGroupMessageSerializer::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(CreateDBClusterParameterGroupError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = CreateDBClusterParameterGroupResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
start_element(&actual_tag_name, &mut stack)?;
result = CreateDBClusterParameterGroupResultDeserializer::deserialize(
"CreateDBClusterParameterGroupResult",
&mut stack,
)?;
skip_tree(&mut stack);
end_element(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn create_db_cluster_snapshot(
&self,
input: CreateDBClusterSnapshotMessage,
) -> RusotoFuture<CreateDBClusterSnapshotResult, CreateDBClusterSnapshotError> {
let mut request = SignedRequest::new("POST", "rds", &self.region, "/");
let mut params = Params::new();
params.put("Action", "CreateDBClusterSnapshot");
params.put("Version", "2014-10-31");
CreateDBClusterSnapshotMessageSerializer::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(CreateDBClusterSnapshotError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = CreateDBClusterSnapshotResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
start_element(&actual_tag_name, &mut stack)?;
result = CreateDBClusterSnapshotResultDeserializer::deserialize(
"CreateDBClusterSnapshotResult",
&mut stack,
)?;
skip_tree(&mut stack);
end_element(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn create_db_instance(
&self,
input: CreateDBInstanceMessage,
) -> RusotoFuture<CreateDBInstanceResult, CreateDBInstanceError> {
let mut request = SignedRequest::new("POST", "rds", &self.region, "/");
let mut params = Params::new();
params.put("Action", "CreateDBInstance");
params.put("Version", "2014-10-31");
CreateDBInstanceMessageSerializer::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(CreateDBInstanceError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = CreateDBInstanceResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
start_element(&actual_tag_name, &mut stack)?;
result = CreateDBInstanceResultDeserializer::deserialize(
"CreateDBInstanceResult",
&mut stack,
)?;
skip_tree(&mut stack);
end_element(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn create_db_parameter_group(
&self,
input: CreateDBParameterGroupMessage,
) -> RusotoFuture<CreateDBParameterGroupResult, CreateDBParameterGroupError> {
let mut request = SignedRequest::new("POST", "rds", &self.region, "/");
let mut params = Params::new();
params.put("Action", "CreateDBParameterGroup");
params.put("Version", "2014-10-31");
CreateDBParameterGroupMessageSerializer::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(CreateDBParameterGroupError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = CreateDBParameterGroupResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
start_element(&actual_tag_name, &mut stack)?;
result = CreateDBParameterGroupResultDeserializer::deserialize(
"CreateDBParameterGroupResult",
&mut stack,
)?;
skip_tree(&mut stack);
end_element(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn create_db_subnet_group(
&self,
input: CreateDBSubnetGroupMessage,
) -> RusotoFuture<CreateDBSubnetGroupResult, CreateDBSubnetGroupError> {
let mut request = SignedRequest::new("POST", "rds", &self.region, "/");
let mut params = Params::new();
params.put("Action", "CreateDBSubnetGroup");
params.put("Version", "2014-10-31");
CreateDBSubnetGroupMessageSerializer::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(CreateDBSubnetGroupError::from_response(response))
}),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = CreateDBSubnetGroupResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
start_element(&actual_tag_name, &mut stack)?;
result = CreateDBSubnetGroupResultDeserializer::deserialize(
"CreateDBSubnetGroupResult",
&mut stack,
)?;
skip_tree(&mut stack);
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", "rds", &self.region, "/");
let mut params = Params::new();
params.put("Action", "CreateEventSubscription");
params.put("Version", "2014-10-31");
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 = peek_at_name(&mut stack)?;
start_element(&actual_tag_name, &mut stack)?;
result = CreateEventSubscriptionResultDeserializer::deserialize(
"CreateEventSubscriptionResult",
&mut stack,
)?;
skip_tree(&mut stack);
end_element(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn delete_db_cluster(
&self,
input: DeleteDBClusterMessage,
) -> RusotoFuture<DeleteDBClusterResult, DeleteDBClusterError> {
let mut request = SignedRequest::new("POST", "rds", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DeleteDBCluster");
params.put("Version", "2014-10-31");
DeleteDBClusterMessageSerializer::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(DeleteDBClusterError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DeleteDBClusterResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
start_element(&actual_tag_name, &mut stack)?;
result = DeleteDBClusterResultDeserializer::deserialize(
"DeleteDBClusterResult",
&mut stack,
)?;
skip_tree(&mut stack);
end_element(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn delete_db_cluster_parameter_group(
&self,
input: DeleteDBClusterParameterGroupMessage,
) -> RusotoFuture<(), DeleteDBClusterParameterGroupError> {
let mut request = SignedRequest::new("POST", "rds", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DeleteDBClusterParameterGroup");
params.put("Version", "2014-10-31");
DeleteDBClusterParameterGroupMessageSerializer::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(DeleteDBClusterParameterGroupError::from_response(response))
}));
}
Box::new(future::ok(::std::mem::drop(response)))
})
}
fn delete_db_cluster_snapshot(
&self,
input: DeleteDBClusterSnapshotMessage,
) -> RusotoFuture<DeleteDBClusterSnapshotResult, DeleteDBClusterSnapshotError> {
let mut request = SignedRequest::new("POST", "rds", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DeleteDBClusterSnapshot");
params.put("Version", "2014-10-31");
DeleteDBClusterSnapshotMessageSerializer::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(DeleteDBClusterSnapshotError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DeleteDBClusterSnapshotResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
start_element(&actual_tag_name, &mut stack)?;
result = DeleteDBClusterSnapshotResultDeserializer::deserialize(
"DeleteDBClusterSnapshotResult",
&mut stack,
)?;
skip_tree(&mut stack);
end_element(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn delete_db_instance(
&self,
input: DeleteDBInstanceMessage,
) -> RusotoFuture<DeleteDBInstanceResult, DeleteDBInstanceError> {
let mut request = SignedRequest::new("POST", "rds", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DeleteDBInstance");
params.put("Version", "2014-10-31");
DeleteDBInstanceMessageSerializer::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(DeleteDBInstanceError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DeleteDBInstanceResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
start_element(&actual_tag_name, &mut stack)?;
result = DeleteDBInstanceResultDeserializer::deserialize(
"DeleteDBInstanceResult",
&mut stack,
)?;
skip_tree(&mut stack);
end_element(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn delete_db_parameter_group(
&self,
input: DeleteDBParameterGroupMessage,
) -> RusotoFuture<(), DeleteDBParameterGroupError> {
let mut request = SignedRequest::new("POST", "rds", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DeleteDBParameterGroup");
params.put("Version", "2014-10-31");
DeleteDBParameterGroupMessageSerializer::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(DeleteDBParameterGroupError::from_response(response))
}));
}
Box::new(future::ok(::std::mem::drop(response)))
})
}
fn delete_db_subnet_group(
&self,
input: DeleteDBSubnetGroupMessage,
) -> RusotoFuture<(), DeleteDBSubnetGroupError> {
let mut request = SignedRequest::new("POST", "rds", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DeleteDBSubnetGroup");
params.put("Version", "2014-10-31");
DeleteDBSubnetGroupMessageSerializer::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(DeleteDBSubnetGroupError::from_response(response))
}),
);
}
Box::new(future::ok(::std::mem::drop(response)))
})
}
fn delete_event_subscription(
&self,
input: DeleteEventSubscriptionMessage,
) -> RusotoFuture<DeleteEventSubscriptionResult, DeleteEventSubscriptionError> {
let mut request = SignedRequest::new("POST", "rds", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DeleteEventSubscription");
params.put("Version", "2014-10-31");
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(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DeleteEventSubscriptionResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
start_element(&actual_tag_name, &mut stack)?;
result = DeleteEventSubscriptionResultDeserializer::deserialize(
"DeleteEventSubscriptionResult",
&mut stack,
)?;
skip_tree(&mut stack);
end_element(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn describe_db_cluster_parameter_groups(
&self,
input: DescribeDBClusterParameterGroupsMessage,
) -> RusotoFuture<DBClusterParameterGroupsMessage, DescribeDBClusterParameterGroupsError> {
let mut request = SignedRequest::new("POST", "rds", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeDBClusterParameterGroups");
params.put("Version", "2014-10-31");
DescribeDBClusterParameterGroupsMessageSerializer::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(DescribeDBClusterParameterGroupsError::from_response(
response,
))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DBClusterParameterGroupsMessage::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
start_element(&actual_tag_name, &mut stack)?;
result = DBClusterParameterGroupsMessageDeserializer::deserialize(
"DescribeDBClusterParameterGroupsResult",
&mut stack,
)?;
skip_tree(&mut stack);
end_element(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn describe_db_cluster_parameters(
&self,
input: DescribeDBClusterParametersMessage,
) -> RusotoFuture<DBClusterParameterGroupDetails, DescribeDBClusterParametersError> {
let mut request = SignedRequest::new("POST", "rds", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeDBClusterParameters");
params.put("Version", "2014-10-31");
DescribeDBClusterParametersMessageSerializer::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(DescribeDBClusterParametersError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DBClusterParameterGroupDetails::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
start_element(&actual_tag_name, &mut stack)?;
result = DBClusterParameterGroupDetailsDeserializer::deserialize(
"DescribeDBClusterParametersResult",
&mut stack,
)?;
skip_tree(&mut stack);
end_element(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn describe_db_cluster_snapshot_attributes(
&self,
input: DescribeDBClusterSnapshotAttributesMessage,
) -> RusotoFuture<
DescribeDBClusterSnapshotAttributesResult,
DescribeDBClusterSnapshotAttributesError,
> {
let mut request = SignedRequest::new("POST", "rds", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeDBClusterSnapshotAttributes");
params.put("Version", "2014-10-31");
DescribeDBClusterSnapshotAttributesMessageSerializer::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(DescribeDBClusterSnapshotAttributesError::from_response(
response,
))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeDBClusterSnapshotAttributesResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
start_element(&actual_tag_name, &mut stack)?;
result = DescribeDBClusterSnapshotAttributesResultDeserializer::deserialize(
"DescribeDBClusterSnapshotAttributesResult",
&mut stack,
)?;
skip_tree(&mut stack);
end_element(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn describe_db_cluster_snapshots(
&self,
input: DescribeDBClusterSnapshotsMessage,
) -> RusotoFuture<DBClusterSnapshotMessage, DescribeDBClusterSnapshotsError> {
let mut request = SignedRequest::new("POST", "rds", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeDBClusterSnapshots");
params.put("Version", "2014-10-31");
DescribeDBClusterSnapshotsMessageSerializer::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(DescribeDBClusterSnapshotsError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DBClusterSnapshotMessage::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
start_element(&actual_tag_name, &mut stack)?;
result = DBClusterSnapshotMessageDeserializer::deserialize(
"DescribeDBClusterSnapshotsResult",
&mut stack,
)?;
skip_tree(&mut stack);
end_element(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn describe_db_clusters(
&self,
input: DescribeDBClustersMessage,
) -> RusotoFuture<DBClusterMessage, DescribeDBClustersError> {
let mut request = SignedRequest::new("POST", "rds", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeDBClusters");
params.put("Version", "2014-10-31");
DescribeDBClustersMessageSerializer::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(DescribeDBClustersError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DBClusterMessage::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
start_element(&actual_tag_name, &mut stack)?;
result = DBClusterMessageDeserializer::deserialize(
"DescribeDBClustersResult",
&mut stack,
)?;
skip_tree(&mut stack);
end_element(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn describe_db_engine_versions(
&self,
input: DescribeDBEngineVersionsMessage,
) -> RusotoFuture<DBEngineVersionMessage, DescribeDBEngineVersionsError> {
let mut request = SignedRequest::new("POST", "rds", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeDBEngineVersions");
params.put("Version", "2014-10-31");
DescribeDBEngineVersionsMessageSerializer::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(DescribeDBEngineVersionsError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DBEngineVersionMessage::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
start_element(&actual_tag_name, &mut stack)?;
result = DBEngineVersionMessageDeserializer::deserialize(
"DescribeDBEngineVersionsResult",
&mut stack,
)?;
skip_tree(&mut stack);
end_element(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn describe_db_instances(
&self,
input: DescribeDBInstancesMessage,
) -> RusotoFuture<DBInstanceMessage, DescribeDBInstancesError> {
let mut request = SignedRequest::new("POST", "rds", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeDBInstances");
params.put("Version", "2014-10-31");
DescribeDBInstancesMessageSerializer::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(DescribeDBInstancesError::from_response(response))
}),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DBInstanceMessage::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
start_element(&actual_tag_name, &mut stack)?;
result = DBInstanceMessageDeserializer::deserialize(
"DescribeDBInstancesResult",
&mut stack,
)?;
skip_tree(&mut stack);
end_element(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn describe_db_parameter_groups(
&self,
input: DescribeDBParameterGroupsMessage,
) -> RusotoFuture<DBParameterGroupsMessage, DescribeDBParameterGroupsError> {
let mut request = SignedRequest::new("POST", "rds", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeDBParameterGroups");
params.put("Version", "2014-10-31");
DescribeDBParameterGroupsMessageSerializer::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(DescribeDBParameterGroupsError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DBParameterGroupsMessage::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
start_element(&actual_tag_name, &mut stack)?;
result = DBParameterGroupsMessageDeserializer::deserialize(
"DescribeDBParameterGroupsResult",
&mut stack,
)?;
skip_tree(&mut stack);
end_element(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn describe_db_parameters(
&self,
input: DescribeDBParametersMessage,
) -> RusotoFuture<DBParameterGroupDetails, DescribeDBParametersError> {
let mut request = SignedRequest::new("POST", "rds", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeDBParameters");
params.put("Version", "2014-10-31");
DescribeDBParametersMessageSerializer::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(DescribeDBParametersError::from_response(response))
}),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DBParameterGroupDetails::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
start_element(&actual_tag_name, &mut stack)?;
result = DBParameterGroupDetailsDeserializer::deserialize(
"DescribeDBParametersResult",
&mut stack,
)?;
skip_tree(&mut stack);
end_element(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn describe_db_subnet_groups(
&self,
input: DescribeDBSubnetGroupsMessage,
) -> RusotoFuture<DBSubnetGroupMessage, DescribeDBSubnetGroupsError> {
let mut request = SignedRequest::new("POST", "rds", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeDBSubnetGroups");
params.put("Version", "2014-10-31");
DescribeDBSubnetGroupsMessageSerializer::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(DescribeDBSubnetGroupsError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DBSubnetGroupMessage::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
start_element(&actual_tag_name, &mut stack)?;
result = DBSubnetGroupMessageDeserializer::deserialize(
"DescribeDBSubnetGroupsResult",
&mut stack,
)?;
skip_tree(&mut stack);
end_element(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn describe_engine_default_cluster_parameters(
&self,
input: DescribeEngineDefaultClusterParametersMessage,
) -> RusotoFuture<
DescribeEngineDefaultClusterParametersResult,
DescribeEngineDefaultClusterParametersError,
> {
let mut request = SignedRequest::new("POST", "rds", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeEngineDefaultClusterParameters");
params.put("Version", "2014-10-31");
DescribeEngineDefaultClusterParametersMessageSerializer::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(DescribeEngineDefaultClusterParametersError::from_response(
response,
))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeEngineDefaultClusterParametersResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
start_element(&actual_tag_name, &mut stack)?;
result = DescribeEngineDefaultClusterParametersResultDeserializer::deserialize(
"DescribeEngineDefaultClusterParametersResult",
&mut stack,
)?;
skip_tree(&mut stack);
end_element(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn describe_engine_default_parameters(
&self,
input: DescribeEngineDefaultParametersMessage,
) -> RusotoFuture<DescribeEngineDefaultParametersResult, DescribeEngineDefaultParametersError>
{
let mut request = SignedRequest::new("POST", "rds", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeEngineDefaultParameters");
params.put("Version", "2014-10-31");
DescribeEngineDefaultParametersMessageSerializer::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(DescribeEngineDefaultParametersError::from_response(
response,
))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeEngineDefaultParametersResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
start_element(&actual_tag_name, &mut stack)?;
result = DescribeEngineDefaultParametersResultDeserializer::deserialize(
"DescribeEngineDefaultParametersResult",
&mut stack,
)?;
skip_tree(&mut stack);
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", "rds", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeEventCategories");
params.put("Version", "2014-10-31");
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 = peek_at_name(&mut stack)?;
start_element(&actual_tag_name, &mut stack)?;
result = EventCategoriesMessageDeserializer::deserialize(
"DescribeEventCategoriesResult",
&mut stack,
)?;
skip_tree(&mut stack);
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", "rds", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeEventSubscriptions");
params.put("Version", "2014-10-31");
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 = peek_at_name(&mut stack)?;
start_element(&actual_tag_name, &mut stack)?;
result = EventSubscriptionsMessageDeserializer::deserialize(
"DescribeEventSubscriptionsResult",
&mut stack,
)?;
skip_tree(&mut stack);
end_element(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn describe_events(
&self,
input: DescribeEventsMessage,
) -> RusotoFuture<EventsMessage, DescribeEventsError> {
let mut request = SignedRequest::new("POST", "rds", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeEvents");
params.put("Version", "2014-10-31");
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 = peek_at_name(&mut stack)?;
start_element(&actual_tag_name, &mut stack)?;
result =
EventsMessageDeserializer::deserialize("DescribeEventsResult", &mut stack)?;
skip_tree(&mut stack);
end_element(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn describe_orderable_db_instance_options(
&self,
input: DescribeOrderableDBInstanceOptionsMessage,
) -> RusotoFuture<OrderableDBInstanceOptionsMessage, DescribeOrderableDBInstanceOptionsError>
{
let mut request = SignedRequest::new("POST", "rds", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeOrderableDBInstanceOptions");
params.put("Version", "2014-10-31");
DescribeOrderableDBInstanceOptionsMessageSerializer::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(DescribeOrderableDBInstanceOptionsError::from_response(
response,
))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = OrderableDBInstanceOptionsMessage::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
start_element(&actual_tag_name, &mut stack)?;
result = OrderableDBInstanceOptionsMessageDeserializer::deserialize(
"DescribeOrderableDBInstanceOptionsResult",
&mut stack,
)?;
skip_tree(&mut stack);
end_element(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn describe_pending_maintenance_actions(
&self,
input: DescribePendingMaintenanceActionsMessage,
) -> RusotoFuture<PendingMaintenanceActionsMessage, DescribePendingMaintenanceActionsError>
{
let mut request = SignedRequest::new("POST", "rds", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribePendingMaintenanceActions");
params.put("Version", "2014-10-31");
DescribePendingMaintenanceActionsMessageSerializer::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(DescribePendingMaintenanceActionsError::from_response(
response,
))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = PendingMaintenanceActionsMessage::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
start_element(&actual_tag_name, &mut stack)?;
result = PendingMaintenanceActionsMessageDeserializer::deserialize(
"DescribePendingMaintenanceActionsResult",
&mut stack,
)?;
skip_tree(&mut stack);
end_element(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn describe_valid_db_instance_modifications(
&self,
input: DescribeValidDBInstanceModificationsMessage,
) -> RusotoFuture<
DescribeValidDBInstanceModificationsResult,
DescribeValidDBInstanceModificationsError,
> {
let mut request = SignedRequest::new("POST", "rds", &self.region, "/");
let mut params = Params::new();
params.put("Action", "DescribeValidDBInstanceModifications");
params.put("Version", "2014-10-31");
DescribeValidDBInstanceModificationsMessageSerializer::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(DescribeValidDBInstanceModificationsError::from_response(
response,
))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DescribeValidDBInstanceModificationsResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
start_element(&actual_tag_name, &mut stack)?;
result = DescribeValidDBInstanceModificationsResultDeserializer::deserialize(
"DescribeValidDBInstanceModificationsResult",
&mut stack,
)?;
skip_tree(&mut stack);
end_element(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn failover_db_cluster(
&self,
input: FailoverDBClusterMessage,
) -> RusotoFuture<FailoverDBClusterResult, FailoverDBClusterError> {
let mut request = SignedRequest::new("POST", "rds", &self.region, "/");
let mut params = Params::new();
params.put("Action", "FailoverDBCluster");
params.put("Version", "2014-10-31");
FailoverDBClusterMessageSerializer::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(FailoverDBClusterError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = FailoverDBClusterResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
start_element(&actual_tag_name, &mut stack)?;
result = FailoverDBClusterResultDeserializer::deserialize(
"FailoverDBClusterResult",
&mut stack,
)?;
skip_tree(&mut stack);
end_element(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn list_tags_for_resource(
&self,
input: ListTagsForResourceMessage,
) -> RusotoFuture<TagListMessage, ListTagsForResourceError> {
let mut request = SignedRequest::new("POST", "rds", &self.region, "/");
let mut params = Params::new();
params.put("Action", "ListTagsForResource");
params.put("Version", "2014-10-31");
ListTagsForResourceMessageSerializer::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(ListTagsForResourceError::from_response(response))
}),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = TagListMessage::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
start_element(&actual_tag_name, &mut stack)?;
result = TagListMessageDeserializer::deserialize(
"ListTagsForResourceResult",
&mut stack,
)?;
skip_tree(&mut stack);
end_element(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn modify_db_cluster(
&self,
input: ModifyDBClusterMessage,
) -> RusotoFuture<ModifyDBClusterResult, ModifyDBClusterError> {
let mut request = SignedRequest::new("POST", "rds", &self.region, "/");
let mut params = Params::new();
params.put("Action", "ModifyDBCluster");
params.put("Version", "2014-10-31");
ModifyDBClusterMessageSerializer::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(ModifyDBClusterError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = ModifyDBClusterResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
start_element(&actual_tag_name, &mut stack)?;
result = ModifyDBClusterResultDeserializer::deserialize(
"ModifyDBClusterResult",
&mut stack,
)?;
skip_tree(&mut stack);
end_element(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn modify_db_cluster_parameter_group(
&self,
input: ModifyDBClusterParameterGroupMessage,
) -> RusotoFuture<DBClusterParameterGroupNameMessage, ModifyDBClusterParameterGroupError> {
let mut request = SignedRequest::new("POST", "rds", &self.region, "/");
let mut params = Params::new();
params.put("Action", "ModifyDBClusterParameterGroup");
params.put("Version", "2014-10-31");
ModifyDBClusterParameterGroupMessageSerializer::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(ModifyDBClusterParameterGroupError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DBClusterParameterGroupNameMessage::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
start_element(&actual_tag_name, &mut stack)?;
result = DBClusterParameterGroupNameMessageDeserializer::deserialize(
"ModifyDBClusterParameterGroupResult",
&mut stack,
)?;
skip_tree(&mut stack);
end_element(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn modify_db_cluster_snapshot_attribute(
&self,
input: ModifyDBClusterSnapshotAttributeMessage,
) -> RusotoFuture<ModifyDBClusterSnapshotAttributeResult, ModifyDBClusterSnapshotAttributeError>
{
let mut request = SignedRequest::new("POST", "rds", &self.region, "/");
let mut params = Params::new();
params.put("Action", "ModifyDBClusterSnapshotAttribute");
params.put("Version", "2014-10-31");
ModifyDBClusterSnapshotAttributeMessageSerializer::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(ModifyDBClusterSnapshotAttributeError::from_response(
response,
))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = ModifyDBClusterSnapshotAttributeResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
start_element(&actual_tag_name, &mut stack)?;
result = ModifyDBClusterSnapshotAttributeResultDeserializer::deserialize(
"ModifyDBClusterSnapshotAttributeResult",
&mut stack,
)?;
skip_tree(&mut stack);
end_element(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn modify_db_instance(
&self,
input: ModifyDBInstanceMessage,
) -> RusotoFuture<ModifyDBInstanceResult, ModifyDBInstanceError> {
let mut request = SignedRequest::new("POST", "rds", &self.region, "/");
let mut params = Params::new();
params.put("Action", "ModifyDBInstance");
params.put("Version", "2014-10-31");
ModifyDBInstanceMessageSerializer::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(ModifyDBInstanceError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = ModifyDBInstanceResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
start_element(&actual_tag_name, &mut stack)?;
result = ModifyDBInstanceResultDeserializer::deserialize(
"ModifyDBInstanceResult",
&mut stack,
)?;
skip_tree(&mut stack);
end_element(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn modify_db_parameter_group(
&self,
input: ModifyDBParameterGroupMessage,
) -> RusotoFuture<DBParameterGroupNameMessage, ModifyDBParameterGroupError> {
let mut request = SignedRequest::new("POST", "rds", &self.region, "/");
let mut params = Params::new();
params.put("Action", "ModifyDBParameterGroup");
params.put("Version", "2014-10-31");
ModifyDBParameterGroupMessageSerializer::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(ModifyDBParameterGroupError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DBParameterGroupNameMessage::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
start_element(&actual_tag_name, &mut stack)?;
result = DBParameterGroupNameMessageDeserializer::deserialize(
"ModifyDBParameterGroupResult",
&mut stack,
)?;
skip_tree(&mut stack);
end_element(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn modify_db_subnet_group(
&self,
input: ModifyDBSubnetGroupMessage,
) -> RusotoFuture<ModifyDBSubnetGroupResult, ModifyDBSubnetGroupError> {
let mut request = SignedRequest::new("POST", "rds", &self.region, "/");
let mut params = Params::new();
params.put("Action", "ModifyDBSubnetGroup");
params.put("Version", "2014-10-31");
ModifyDBSubnetGroupMessageSerializer::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(ModifyDBSubnetGroupError::from_response(response))
}),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = ModifyDBSubnetGroupResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
start_element(&actual_tag_name, &mut stack)?;
result = ModifyDBSubnetGroupResultDeserializer::deserialize(
"ModifyDBSubnetGroupResult",
&mut stack,
)?;
skip_tree(&mut stack);
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", "rds", &self.region, "/");
let mut params = Params::new();
params.put("Action", "ModifyEventSubscription");
params.put("Version", "2014-10-31");
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 = peek_at_name(&mut stack)?;
start_element(&actual_tag_name, &mut stack)?;
result = ModifyEventSubscriptionResultDeserializer::deserialize(
"ModifyEventSubscriptionResult",
&mut stack,
)?;
skip_tree(&mut stack);
end_element(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn promote_read_replica_db_cluster(
&self,
input: PromoteReadReplicaDBClusterMessage,
) -> RusotoFuture<PromoteReadReplicaDBClusterResult, PromoteReadReplicaDBClusterError> {
let mut request = SignedRequest::new("POST", "rds", &self.region, "/");
let mut params = Params::new();
params.put("Action", "PromoteReadReplicaDBCluster");
params.put("Version", "2014-10-31");
PromoteReadReplicaDBClusterMessageSerializer::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(PromoteReadReplicaDBClusterError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = PromoteReadReplicaDBClusterResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
start_element(&actual_tag_name, &mut stack)?;
result = PromoteReadReplicaDBClusterResultDeserializer::deserialize(
"PromoteReadReplicaDBClusterResult",
&mut stack,
)?;
skip_tree(&mut stack);
end_element(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn reboot_db_instance(
&self,
input: RebootDBInstanceMessage,
) -> RusotoFuture<RebootDBInstanceResult, RebootDBInstanceError> {
let mut request = SignedRequest::new("POST", "rds", &self.region, "/");
let mut params = Params::new();
params.put("Action", "RebootDBInstance");
params.put("Version", "2014-10-31");
RebootDBInstanceMessageSerializer::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(RebootDBInstanceError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = RebootDBInstanceResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
start_element(&actual_tag_name, &mut stack)?;
result = RebootDBInstanceResultDeserializer::deserialize(
"RebootDBInstanceResult",
&mut stack,
)?;
skip_tree(&mut stack);
end_element(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn remove_role_from_db_cluster(
&self,
input: RemoveRoleFromDBClusterMessage,
) -> RusotoFuture<(), RemoveRoleFromDBClusterError> {
let mut request = SignedRequest::new("POST", "rds", &self.region, "/");
let mut params = Params::new();
params.put("Action", "RemoveRoleFromDBCluster");
params.put("Version", "2014-10-31");
RemoveRoleFromDBClusterMessageSerializer::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(RemoveRoleFromDBClusterError::from_response(response))
}));
}
Box::new(future::ok(::std::mem::drop(response)))
})
}
fn remove_source_identifier_from_subscription(
&self,
input: RemoveSourceIdentifierFromSubscriptionMessage,
) -> RusotoFuture<
RemoveSourceIdentifierFromSubscriptionResult,
RemoveSourceIdentifierFromSubscriptionError,
> {
let mut request = SignedRequest::new("POST", "rds", &self.region, "/");
let mut params = Params::new();
params.put("Action", "RemoveSourceIdentifierFromSubscription");
params.put("Version", "2014-10-31");
RemoveSourceIdentifierFromSubscriptionMessageSerializer::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(RemoveSourceIdentifierFromSubscriptionError::from_response(
response,
))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = RemoveSourceIdentifierFromSubscriptionResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
start_element(&actual_tag_name, &mut stack)?;
result = RemoveSourceIdentifierFromSubscriptionResultDeserializer::deserialize(
"RemoveSourceIdentifierFromSubscriptionResult",
&mut stack,
)?;
skip_tree(&mut stack);
end_element(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn remove_tags_from_resource(
&self,
input: RemoveTagsFromResourceMessage,
) -> RusotoFuture<(), RemoveTagsFromResourceError> {
let mut request = SignedRequest::new("POST", "rds", &self.region, "/");
let mut params = Params::new();
params.put("Action", "RemoveTagsFromResource");
params.put("Version", "2014-10-31");
RemoveTagsFromResourceMessageSerializer::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(RemoveTagsFromResourceError::from_response(response))
}));
}
Box::new(future::ok(::std::mem::drop(response)))
})
}
fn reset_db_cluster_parameter_group(
&self,
input: ResetDBClusterParameterGroupMessage,
) -> RusotoFuture<DBClusterParameterGroupNameMessage, ResetDBClusterParameterGroupError> {
let mut request = SignedRequest::new("POST", "rds", &self.region, "/");
let mut params = Params::new();
params.put("Action", "ResetDBClusterParameterGroup");
params.put("Version", "2014-10-31");
ResetDBClusterParameterGroupMessageSerializer::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(ResetDBClusterParameterGroupError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DBClusterParameterGroupNameMessage::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
start_element(&actual_tag_name, &mut stack)?;
result = DBClusterParameterGroupNameMessageDeserializer::deserialize(
"ResetDBClusterParameterGroupResult",
&mut stack,
)?;
skip_tree(&mut stack);
end_element(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn reset_db_parameter_group(
&self,
input: ResetDBParameterGroupMessage,
) -> RusotoFuture<DBParameterGroupNameMessage, ResetDBParameterGroupError> {
let mut request = SignedRequest::new("POST", "rds", &self.region, "/");
let mut params = Params::new();
params.put("Action", "ResetDBParameterGroup");
params.put("Version", "2014-10-31");
ResetDBParameterGroupMessageSerializer::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(ResetDBParameterGroupError::from_response(response))
}),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = DBParameterGroupNameMessage::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
start_element(&actual_tag_name, &mut stack)?;
result = DBParameterGroupNameMessageDeserializer::deserialize(
"ResetDBParameterGroupResult",
&mut stack,
)?;
skip_tree(&mut stack);
end_element(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn restore_db_cluster_from_snapshot(
&self,
input: RestoreDBClusterFromSnapshotMessage,
) -> RusotoFuture<RestoreDBClusterFromSnapshotResult, RestoreDBClusterFromSnapshotError> {
let mut request = SignedRequest::new("POST", "rds", &self.region, "/");
let mut params = Params::new();
params.put("Action", "RestoreDBClusterFromSnapshot");
params.put("Version", "2014-10-31");
RestoreDBClusterFromSnapshotMessageSerializer::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(RestoreDBClusterFromSnapshotError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = RestoreDBClusterFromSnapshotResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
start_element(&actual_tag_name, &mut stack)?;
result = RestoreDBClusterFromSnapshotResultDeserializer::deserialize(
"RestoreDBClusterFromSnapshotResult",
&mut stack,
)?;
skip_tree(&mut stack);
end_element(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
fn restore_db_cluster_to_point_in_time(
&self,
input: RestoreDBClusterToPointInTimeMessage,
) -> RusotoFuture<RestoreDBClusterToPointInTimeResult, RestoreDBClusterToPointInTimeError> {
let mut request = SignedRequest::new("POST", "rds", &self.region, "/");
let mut params = Params::new();
params.put("Action", "RestoreDBClusterToPointInTime");
params.put("Version", "2014-10-31");
RestoreDBClusterToPointInTimeMessageSerializer::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(RestoreDBClusterToPointInTimeError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let result;
if response.body.is_empty() {
result = RestoreDBClusterToPointInTimeResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
start_element(&actual_tag_name, &mut stack)?;
result = RestoreDBClusterToPointInTimeResultDeserializer::deserialize(
"RestoreDBClusterToPointInTimeResult",
&mut stack,
)?;
skip_tree(&mut stack);
end_element(&actual_tag_name, &mut stack)?;
}
Ok(result)
}))
})
}
}
#[cfg(test)]
mod protocol_tests {}