use std::error::Error;
use std::fmt;
use async_trait::async_trait;
use rusoto_core::credential::ProvideAwsCredentials;
use rusoto_core::region;
use rusoto_core::request::{BufferedHttpResponse, DispatchSignedRequest};
use rusoto_core::{Client, RusotoError};
use rusoto_core::param::{Params, ServiceParams};
use rusoto_core::proto::xml::error::*;
use rusoto_core::proto::xml::util::{
self as xml_util, deserialize_elements, find_start_element, skip_tree,
};
use rusoto_core::proto::xml::util::{Next, Peek, XmlParseError, XmlResponse};
use rusoto_core::request::HttpResponse;
use rusoto_core::signature::SignedRequest;
#[cfg(feature = "deserialize_structs")]
use serde::Deserialize;
#[cfg(feature = "serialize_structs")]
use serde::Serialize;
use serde_urlencoded;
use std::str::FromStr;
use xml::EventReader;
impl ElastiCacheClient {
fn new_params(&self, operation_name: &str) -> Params {
let mut params = Params::new();
params.put("Action", operation_name);
params.put("Version", "2015-02-02");
params
}
async fn sign_and_dispatch<E>(
&self,
request: SignedRequest,
from_response: fn(BufferedHttpResponse) -> RusotoError<E>,
) -> Result<HttpResponse, RusotoError<E>> {
let mut response = self.client.sign_and_dispatch(request).await?;
if !response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
return Err(from_response(response));
}
Ok(response)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct 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);
}
}
#[allow(dead_code)]
struct AllowedNodeGroupIdDeserializer;
impl AllowedNodeGroupIdDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct AllowedNodeTypeModificationsMessage {
pub scale_down_modifications: Option<Vec<String>>,
pub scale_up_modifications: Option<Vec<String>>,
}
#[allow(dead_code)]
struct AllowedNodeTypeModificationsMessageDeserializer;
impl AllowedNodeTypeModificationsMessageDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<AllowedNodeTypeModificationsMessage, XmlParseError> {
deserialize_elements::<_, AllowedNodeTypeModificationsMessage, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"ScaleDownModifications" => {
obj.scale_down_modifications.get_or_insert(vec![]).extend(
NodeTypeListDeserializer::deserialize("ScaleDownModifications", stack)?,
);
}
"ScaleUpModifications" => {
obj.scale_up_modifications.get_or_insert(vec![]).extend(
NodeTypeListDeserializer::deserialize("ScaleUpModifications", stack)?,
);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[allow(dead_code)]
struct AuthTokenUpdateStatusDeserializer;
impl AuthTokenUpdateStatusDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AuthorizeCacheSecurityGroupIngressMessage {
pub cache_security_group_name: String,
pub ec2_security_group_name: String,
pub ec2_security_group_owner_id: String,
}
struct AuthorizeCacheSecurityGroupIngressMessageSerializer;
impl AuthorizeCacheSecurityGroupIngressMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &AuthorizeCacheSecurityGroupIngressMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "CacheSecurityGroupName"),
&obj.cache_security_group_name,
);
params.put(
&format!("{}{}", prefix, "EC2SecurityGroupName"),
&obj.ec2_security_group_name,
);
params.put(
&format!("{}{}", prefix, "EC2SecurityGroupOwnerId"),
&obj.ec2_security_group_owner_id,
);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct AuthorizeCacheSecurityGroupIngressResult {
pub cache_security_group: Option<CacheSecurityGroup>,
}
#[allow(dead_code)]
struct AuthorizeCacheSecurityGroupIngressResultDeserializer;
impl AuthorizeCacheSecurityGroupIngressResultDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<AuthorizeCacheSecurityGroupIngressResult, XmlParseError> {
deserialize_elements::<_, AuthorizeCacheSecurityGroupIngressResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"CacheSecurityGroup" => {
obj.cache_security_group =
Some(CacheSecurityGroupDeserializer::deserialize(
"CacheSecurityGroup",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[allow(dead_code)]
struct AutomaticFailoverStatusDeserializer;
impl AutomaticFailoverStatusDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct AvailabilityZone {
pub name: Option<String>,
}
#[allow(dead_code)]
struct AvailabilityZoneDeserializer;
impl AvailabilityZoneDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<AvailabilityZone, XmlParseError> {
deserialize_elements::<_, AvailabilityZone, _>(tag_name, stack, |name, stack, obj| {
match name {
"Name" => {
obj.name = Some(StringDeserializer::deserialize("Name", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[allow(dead_code)]
struct AvailabilityZonesListDeserializer;
impl AvailabilityZonesListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<String>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "AvailabilityZone" {
obj.push(StringDeserializer::deserialize("AvailabilityZone", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct AvailabilityZonesListSerializer;
impl AvailabilityZonesListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.member.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct BatchApplyUpdateActionMessage {
pub cache_cluster_ids: Option<Vec<String>>,
pub replication_group_ids: Option<Vec<String>>,
pub service_update_name: String,
}
struct BatchApplyUpdateActionMessageSerializer;
impl BatchApplyUpdateActionMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &BatchApplyUpdateActionMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.cache_cluster_ids {
CacheClusterIdListSerializer::serialize(
params,
&format!("{}{}", prefix, "CacheClusterIds"),
field_value,
);
}
if let Some(ref field_value) = obj.replication_group_ids {
ReplicationGroupIdListSerializer::serialize(
params,
&format!("{}{}", prefix, "ReplicationGroupIds"),
field_value,
);
}
params.put(
&format!("{}{}", prefix, "ServiceUpdateName"),
&obj.service_update_name,
);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct BatchStopUpdateActionMessage {
pub cache_cluster_ids: Option<Vec<String>>,
pub replication_group_ids: Option<Vec<String>>,
pub service_update_name: String,
}
struct BatchStopUpdateActionMessageSerializer;
impl BatchStopUpdateActionMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &BatchStopUpdateActionMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.cache_cluster_ids {
CacheClusterIdListSerializer::serialize(
params,
&format!("{}{}", prefix, "CacheClusterIds"),
field_value,
);
}
if let Some(ref field_value) = obj.replication_group_ids {
ReplicationGroupIdListSerializer::serialize(
params,
&format!("{}{}", prefix, "ReplicationGroupIds"),
field_value,
);
}
params.put(
&format!("{}{}", prefix, "ServiceUpdateName"),
&obj.service_update_name,
);
}
}
#[allow(dead_code)]
struct BooleanDeserializer;
impl BooleanDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<bool, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, |s| Ok(bool::from_str(&s).unwrap()))
}
}
#[allow(dead_code)]
struct BooleanOptionalDeserializer;
impl BooleanOptionalDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<bool, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, |s| Ok(bool::from_str(&s).unwrap()))
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct CacheCluster {
pub arn: Option<String>,
pub at_rest_encryption_enabled: Option<bool>,
pub auth_token_enabled: Option<bool>,
pub auth_token_last_modified_date: Option<String>,
pub auto_minor_version_upgrade: Option<bool>,
pub cache_cluster_create_time: Option<String>,
pub cache_cluster_id: Option<String>,
pub cache_cluster_status: Option<String>,
pub cache_node_type: Option<String>,
pub cache_nodes: Option<Vec<CacheNode>>,
pub cache_parameter_group: Option<CacheParameterGroupStatus>,
pub cache_security_groups: Option<Vec<CacheSecurityGroupMembership>>,
pub cache_subnet_group_name: Option<String>,
pub client_download_landing_page: Option<String>,
pub configuration_endpoint: Option<Endpoint>,
pub engine: Option<String>,
pub engine_version: Option<String>,
pub notification_configuration: Option<NotificationConfiguration>,
pub num_cache_nodes: Option<i64>,
pub pending_modified_values: Option<PendingModifiedValues>,
pub preferred_availability_zone: Option<String>,
pub preferred_maintenance_window: Option<String>,
pub replication_group_id: Option<String>,
pub security_groups: Option<Vec<SecurityGroupMembership>>,
pub snapshot_retention_limit: Option<i64>,
pub snapshot_window: Option<String>,
pub transit_encryption_enabled: Option<bool>,
}
#[allow(dead_code)]
struct CacheClusterDeserializer;
impl CacheClusterDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CacheCluster, XmlParseError> {
deserialize_elements::<_, CacheCluster, _>(tag_name, stack, |name, stack, obj| {
match name {
"ARN" => {
obj.arn = Some(StringDeserializer::deserialize("ARN", stack)?);
}
"AtRestEncryptionEnabled" => {
obj.at_rest_encryption_enabled = Some(
BooleanOptionalDeserializer::deserialize("AtRestEncryptionEnabled", stack)?,
);
}
"AuthTokenEnabled" => {
obj.auth_token_enabled = Some(BooleanOptionalDeserializer::deserialize(
"AuthTokenEnabled",
stack,
)?);
}
"AuthTokenLastModifiedDate" => {
obj.auth_token_last_modified_date = Some(TStampDeserializer::deserialize(
"AuthTokenLastModifiedDate",
stack,
)?);
}
"AutoMinorVersionUpgrade" => {
obj.auto_minor_version_upgrade = Some(BooleanDeserializer::deserialize(
"AutoMinorVersionUpgrade",
stack,
)?);
}
"CacheClusterCreateTime" => {
obj.cache_cluster_create_time = Some(TStampDeserializer::deserialize(
"CacheClusterCreateTime",
stack,
)?);
}
"CacheClusterId" => {
obj.cache_cluster_id =
Some(StringDeserializer::deserialize("CacheClusterId", stack)?);
}
"CacheClusterStatus" => {
obj.cache_cluster_status = Some(StringDeserializer::deserialize(
"CacheClusterStatus",
stack,
)?);
}
"CacheNodeType" => {
obj.cache_node_type =
Some(StringDeserializer::deserialize("CacheNodeType", stack)?);
}
"CacheNodes" => {
obj.cache_nodes
.get_or_insert(vec![])
.extend(CacheNodeListDeserializer::deserialize("CacheNodes", stack)?);
}
"CacheParameterGroup" => {
obj.cache_parameter_group =
Some(CacheParameterGroupStatusDeserializer::deserialize(
"CacheParameterGroup",
stack,
)?);
}
"CacheSecurityGroups" => {
obj.cache_security_groups.get_or_insert(vec![]).extend(
CacheSecurityGroupMembershipListDeserializer::deserialize(
"CacheSecurityGroups",
stack,
)?,
);
}
"CacheSubnetGroupName" => {
obj.cache_subnet_group_name = Some(StringDeserializer::deserialize(
"CacheSubnetGroupName",
stack,
)?);
}
"ClientDownloadLandingPage" => {
obj.client_download_landing_page = Some(StringDeserializer::deserialize(
"ClientDownloadLandingPage",
stack,
)?);
}
"ConfigurationEndpoint" => {
obj.configuration_endpoint = Some(EndpointDeserializer::deserialize(
"ConfigurationEndpoint",
stack,
)?);
}
"Engine" => {
obj.engine = Some(StringDeserializer::deserialize("Engine", stack)?);
}
"EngineVersion" => {
obj.engine_version =
Some(StringDeserializer::deserialize("EngineVersion", stack)?);
}
"NotificationConfiguration" => {
obj.notification_configuration =
Some(NotificationConfigurationDeserializer::deserialize(
"NotificationConfiguration",
stack,
)?);
}
"NumCacheNodes" => {
obj.num_cache_nodes = Some(IntegerOptionalDeserializer::deserialize(
"NumCacheNodes",
stack,
)?);
}
"PendingModifiedValues" => {
obj.pending_modified_values =
Some(PendingModifiedValuesDeserializer::deserialize(
"PendingModifiedValues",
stack,
)?);
}
"PreferredAvailabilityZone" => {
obj.preferred_availability_zone = Some(StringDeserializer::deserialize(
"PreferredAvailabilityZone",
stack,
)?);
}
"PreferredMaintenanceWindow" => {
obj.preferred_maintenance_window = Some(StringDeserializer::deserialize(
"PreferredMaintenanceWindow",
stack,
)?);
}
"ReplicationGroupId" => {
obj.replication_group_id = Some(StringDeserializer::deserialize(
"ReplicationGroupId",
stack,
)?);
}
"SecurityGroups" => {
obj.security_groups.get_or_insert(vec![]).extend(
SecurityGroupMembershipListDeserializer::deserialize(
"SecurityGroups",
stack,
)?,
);
}
"SnapshotRetentionLimit" => {
obj.snapshot_retention_limit = Some(IntegerOptionalDeserializer::deserialize(
"SnapshotRetentionLimit",
stack,
)?);
}
"SnapshotWindow" => {
obj.snapshot_window =
Some(StringDeserializer::deserialize("SnapshotWindow", stack)?);
}
"TransitEncryptionEnabled" => {
obj.transit_encryption_enabled =
Some(BooleanOptionalDeserializer::deserialize(
"TransitEncryptionEnabled",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct CacheClusterIdListSerializer;
impl CacheClusterIdListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.member.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
#[allow(dead_code)]
struct CacheClusterListDeserializer;
impl CacheClusterListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<CacheCluster>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "CacheCluster" {
obj.push(CacheClusterDeserializer::deserialize(
"CacheCluster",
stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct CacheClusterMessage {
pub cache_clusters: Option<Vec<CacheCluster>>,
pub marker: Option<String>,
}
#[allow(dead_code)]
struct CacheClusterMessageDeserializer;
impl CacheClusterMessageDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CacheClusterMessage, XmlParseError> {
deserialize_elements::<_, CacheClusterMessage, _>(tag_name, stack, |name, stack, obj| {
match name {
"CacheClusters" => {
obj.cache_clusters.get_or_insert(vec![]).extend(
CacheClusterListDeserializer::deserialize("CacheClusters", stack)?,
);
}
"Marker" => {
obj.marker = Some(StringDeserializer::deserialize("Marker", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct CacheEngineVersion {
pub cache_engine_description: Option<String>,
pub cache_engine_version_description: Option<String>,
pub cache_parameter_group_family: Option<String>,
pub engine: Option<String>,
pub engine_version: Option<String>,
}
#[allow(dead_code)]
struct CacheEngineVersionDeserializer;
impl CacheEngineVersionDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CacheEngineVersion, XmlParseError> {
deserialize_elements::<_, CacheEngineVersion, _>(tag_name, stack, |name, stack, obj| {
match name {
"CacheEngineDescription" => {
obj.cache_engine_description = Some(StringDeserializer::deserialize(
"CacheEngineDescription",
stack,
)?);
}
"CacheEngineVersionDescription" => {
obj.cache_engine_version_description = Some(StringDeserializer::deserialize(
"CacheEngineVersionDescription",
stack,
)?);
}
"CacheParameterGroupFamily" => {
obj.cache_parameter_group_family = Some(StringDeserializer::deserialize(
"CacheParameterGroupFamily",
stack,
)?);
}
"Engine" => {
obj.engine = Some(StringDeserializer::deserialize("Engine", stack)?);
}
"EngineVersion" => {
obj.engine_version =
Some(StringDeserializer::deserialize("EngineVersion", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[allow(dead_code)]
struct CacheEngineVersionListDeserializer;
impl CacheEngineVersionListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<CacheEngineVersion>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "CacheEngineVersion" {
obj.push(CacheEngineVersionDeserializer::deserialize(
"CacheEngineVersion",
stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct CacheEngineVersionMessage {
pub cache_engine_versions: Option<Vec<CacheEngineVersion>>,
pub marker: Option<String>,
}
#[allow(dead_code)]
struct CacheEngineVersionMessageDeserializer;
impl CacheEngineVersionMessageDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CacheEngineVersionMessage, XmlParseError> {
deserialize_elements::<_, CacheEngineVersionMessage, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"CacheEngineVersions" => {
obj.cache_engine_versions.get_or_insert(vec![]).extend(
CacheEngineVersionListDeserializer::deserialize(
"CacheEngineVersions",
stack,
)?,
);
}
"Marker" => {
obj.marker = Some(StringDeserializer::deserialize("Marker", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct CacheNode {
pub cache_node_create_time: Option<String>,
pub cache_node_id: Option<String>,
pub cache_node_status: Option<String>,
pub customer_availability_zone: Option<String>,
pub endpoint: Option<Endpoint>,
pub parameter_group_status: Option<String>,
pub source_cache_node_id: Option<String>,
}
#[allow(dead_code)]
struct CacheNodeDeserializer;
impl CacheNodeDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CacheNode, XmlParseError> {
deserialize_elements::<_, CacheNode, _>(tag_name, stack, |name, stack, obj| {
match name {
"CacheNodeCreateTime" => {
obj.cache_node_create_time = Some(TStampDeserializer::deserialize(
"CacheNodeCreateTime",
stack,
)?);
}
"CacheNodeId" => {
obj.cache_node_id =
Some(StringDeserializer::deserialize("CacheNodeId", stack)?);
}
"CacheNodeStatus" => {
obj.cache_node_status =
Some(StringDeserializer::deserialize("CacheNodeStatus", stack)?);
}
"CustomerAvailabilityZone" => {
obj.customer_availability_zone = Some(StringDeserializer::deserialize(
"CustomerAvailabilityZone",
stack,
)?);
}
"Endpoint" => {
obj.endpoint = Some(EndpointDeserializer::deserialize("Endpoint", stack)?);
}
"ParameterGroupStatus" => {
obj.parameter_group_status = Some(StringDeserializer::deserialize(
"ParameterGroupStatus",
stack,
)?);
}
"SourceCacheNodeId" => {
obj.source_cache_node_id =
Some(StringDeserializer::deserialize("SourceCacheNodeId", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[allow(dead_code)]
struct CacheNodeIdsListDeserializer;
impl CacheNodeIdsListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<String>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "CacheNodeId" {
obj.push(StringDeserializer::deserialize("CacheNodeId", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct CacheNodeIdsListSerializer;
impl CacheNodeIdsListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.member.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
#[allow(dead_code)]
struct CacheNodeListDeserializer;
impl CacheNodeListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<CacheNode>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "CacheNode" {
obj.push(CacheNodeDeserializer::deserialize("CacheNode", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct CacheNodeTypeSpecificParameter {
pub allowed_values: Option<String>,
pub cache_node_type_specific_values: Option<Vec<CacheNodeTypeSpecificValue>>,
pub change_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 source: Option<String>,
}
#[allow(dead_code)]
struct CacheNodeTypeSpecificParameterDeserializer;
impl CacheNodeTypeSpecificParameterDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CacheNodeTypeSpecificParameter, XmlParseError> {
deserialize_elements::<_, CacheNodeTypeSpecificParameter, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"AllowedValues" => {
obj.allowed_values =
Some(StringDeserializer::deserialize("AllowedValues", stack)?);
}
"CacheNodeTypeSpecificValues" => {
obj.cache_node_type_specific_values
.get_or_insert(vec![])
.extend(CacheNodeTypeSpecificValueListDeserializer::deserialize(
"CacheNodeTypeSpecificValues",
stack,
)?);
}
"ChangeType" => {
obj.change_type =
Some(ChangeTypeDeserializer::deserialize("ChangeType", 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)?);
}
"Source" => {
obj.source = Some(StringDeserializer::deserialize("Source", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[allow(dead_code)]
struct CacheNodeTypeSpecificParametersListDeserializer;
impl CacheNodeTypeSpecificParametersListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<CacheNodeTypeSpecificParameter>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "CacheNodeTypeSpecificParameter" {
obj.push(CacheNodeTypeSpecificParameterDeserializer::deserialize(
"CacheNodeTypeSpecificParameter",
stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct CacheNodeTypeSpecificValue {
pub cache_node_type: Option<String>,
pub value: Option<String>,
}
#[allow(dead_code)]
struct CacheNodeTypeSpecificValueDeserializer;
impl CacheNodeTypeSpecificValueDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CacheNodeTypeSpecificValue, XmlParseError> {
deserialize_elements::<_, CacheNodeTypeSpecificValue, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"CacheNodeType" => {
obj.cache_node_type =
Some(StringDeserializer::deserialize("CacheNodeType", stack)?);
}
"Value" => {
obj.value = Some(StringDeserializer::deserialize("Value", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[allow(dead_code)]
struct CacheNodeTypeSpecificValueListDeserializer;
impl CacheNodeTypeSpecificValueListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<CacheNodeTypeSpecificValue>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "CacheNodeTypeSpecificValue" {
obj.push(CacheNodeTypeSpecificValueDeserializer::deserialize(
"CacheNodeTypeSpecificValue",
stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct CacheNodeUpdateStatus {
pub cache_node_id: Option<String>,
pub node_deletion_date: Option<String>,
pub node_update_end_date: Option<String>,
pub node_update_initiated_by: Option<String>,
pub node_update_initiated_date: Option<String>,
pub node_update_start_date: Option<String>,
pub node_update_status: Option<String>,
pub node_update_status_modified_date: Option<String>,
}
#[allow(dead_code)]
struct CacheNodeUpdateStatusDeserializer;
impl CacheNodeUpdateStatusDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CacheNodeUpdateStatus, XmlParseError> {
deserialize_elements::<_, CacheNodeUpdateStatus, _>(tag_name, stack, |name, stack, obj| {
match name {
"CacheNodeId" => {
obj.cache_node_id =
Some(StringDeserializer::deserialize("CacheNodeId", stack)?);
}
"NodeDeletionDate" => {
obj.node_deletion_date =
Some(TStampDeserializer::deserialize("NodeDeletionDate", stack)?);
}
"NodeUpdateEndDate" => {
obj.node_update_end_date =
Some(TStampDeserializer::deserialize("NodeUpdateEndDate", stack)?);
}
"NodeUpdateInitiatedBy" => {
obj.node_update_initiated_by =
Some(NodeUpdateInitiatedByDeserializer::deserialize(
"NodeUpdateInitiatedBy",
stack,
)?);
}
"NodeUpdateInitiatedDate" => {
obj.node_update_initiated_date = Some(TStampDeserializer::deserialize(
"NodeUpdateInitiatedDate",
stack,
)?);
}
"NodeUpdateStartDate" => {
obj.node_update_start_date = Some(TStampDeserializer::deserialize(
"NodeUpdateStartDate",
stack,
)?);
}
"NodeUpdateStatus" => {
obj.node_update_status = Some(NodeUpdateStatusDeserializer::deserialize(
"NodeUpdateStatus",
stack,
)?);
}
"NodeUpdateStatusModifiedDate" => {
obj.node_update_status_modified_date = Some(TStampDeserializer::deserialize(
"NodeUpdateStatusModifiedDate",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[allow(dead_code)]
struct CacheNodeUpdateStatusListDeserializer;
impl CacheNodeUpdateStatusListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<CacheNodeUpdateStatus>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "CacheNodeUpdateStatus" {
obj.push(CacheNodeUpdateStatusDeserializer::deserialize(
"CacheNodeUpdateStatus",
stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct CacheParameterGroup {
pub arn: Option<String>,
pub cache_parameter_group_family: Option<String>,
pub cache_parameter_group_name: Option<String>,
pub description: Option<String>,
pub is_global: Option<bool>,
}
#[allow(dead_code)]
struct CacheParameterGroupDeserializer;
impl CacheParameterGroupDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CacheParameterGroup, XmlParseError> {
deserialize_elements::<_, CacheParameterGroup, _>(tag_name, stack, |name, stack, obj| {
match name {
"ARN" => {
obj.arn = Some(StringDeserializer::deserialize("ARN", stack)?);
}
"CacheParameterGroupFamily" => {
obj.cache_parameter_group_family = Some(StringDeserializer::deserialize(
"CacheParameterGroupFamily",
stack,
)?);
}
"CacheParameterGroupName" => {
obj.cache_parameter_group_name = Some(StringDeserializer::deserialize(
"CacheParameterGroupName",
stack,
)?);
}
"Description" => {
obj.description = Some(StringDeserializer::deserialize("Description", stack)?);
}
"IsGlobal" => {
obj.is_global = Some(BooleanDeserializer::deserialize("IsGlobal", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct CacheParameterGroupDetails {
pub cache_node_type_specific_parameters: Option<Vec<CacheNodeTypeSpecificParameter>>,
pub marker: Option<String>,
pub parameters: Option<Vec<Parameter>>,
}
#[allow(dead_code)]
struct CacheParameterGroupDetailsDeserializer;
impl CacheParameterGroupDetailsDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CacheParameterGroupDetails, XmlParseError> {
deserialize_elements::<_, CacheParameterGroupDetails, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"CacheNodeTypeSpecificParameters" => {
obj.cache_node_type_specific_parameters
.get_or_insert(vec![])
.extend(
CacheNodeTypeSpecificParametersListDeserializer::deserialize(
"CacheNodeTypeSpecificParameters",
stack,
)?,
);
}
"Marker" => {
obj.marker = Some(StringDeserializer::deserialize("Marker", stack)?);
}
"Parameters" => {
obj.parameters.get_or_insert(vec![]).extend(
ParametersListDeserializer::deserialize("Parameters", stack)?,
);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[allow(dead_code)]
struct CacheParameterGroupListDeserializer;
impl CacheParameterGroupListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<CacheParameterGroup>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "CacheParameterGroup" {
obj.push(CacheParameterGroupDeserializer::deserialize(
"CacheParameterGroup",
stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct CacheParameterGroupNameMessage {
pub cache_parameter_group_name: Option<String>,
}
#[allow(dead_code)]
struct CacheParameterGroupNameMessageDeserializer;
impl CacheParameterGroupNameMessageDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CacheParameterGroupNameMessage, XmlParseError> {
deserialize_elements::<_, CacheParameterGroupNameMessage, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"CacheParameterGroupName" => {
obj.cache_parameter_group_name = Some(StringDeserializer::deserialize(
"CacheParameterGroupName",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct CacheParameterGroupStatus {
pub cache_node_ids_to_reboot: Option<Vec<String>>,
pub cache_parameter_group_name: Option<String>,
pub parameter_apply_status: Option<String>,
}
#[allow(dead_code)]
struct CacheParameterGroupStatusDeserializer;
impl CacheParameterGroupStatusDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CacheParameterGroupStatus, XmlParseError> {
deserialize_elements::<_, CacheParameterGroupStatus, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"CacheNodeIdsToReboot" => {
obj.cache_node_ids_to_reboot.get_or_insert(vec![]).extend(
CacheNodeIdsListDeserializer::deserialize(
"CacheNodeIdsToReboot",
stack,
)?,
);
}
"CacheParameterGroupName" => {
obj.cache_parameter_group_name = Some(StringDeserializer::deserialize(
"CacheParameterGroupName",
stack,
)?);
}
"ParameterApplyStatus" => {
obj.parameter_apply_status = Some(StringDeserializer::deserialize(
"ParameterApplyStatus",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct CacheParameterGroupsMessage {
pub cache_parameter_groups: Option<Vec<CacheParameterGroup>>,
pub marker: Option<String>,
}
#[allow(dead_code)]
struct CacheParameterGroupsMessageDeserializer;
impl CacheParameterGroupsMessageDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CacheParameterGroupsMessage, XmlParseError> {
deserialize_elements::<_, CacheParameterGroupsMessage, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"CacheParameterGroups" => {
obj.cache_parameter_groups.get_or_insert(vec![]).extend(
CacheParameterGroupListDeserializer::deserialize(
"CacheParameterGroups",
stack,
)?,
);
}
"Marker" => {
obj.marker = Some(StringDeserializer::deserialize("Marker", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct CacheSecurityGroup {
pub arn: Option<String>,
pub cache_security_group_name: Option<String>,
pub description: Option<String>,
pub ec2_security_groups: Option<Vec<EC2SecurityGroup>>,
pub owner_id: Option<String>,
}
#[allow(dead_code)]
struct CacheSecurityGroupDeserializer;
impl CacheSecurityGroupDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CacheSecurityGroup, XmlParseError> {
deserialize_elements::<_, CacheSecurityGroup, _>(tag_name, stack, |name, stack, obj| {
match name {
"ARN" => {
obj.arn = Some(StringDeserializer::deserialize("ARN", stack)?);
}
"CacheSecurityGroupName" => {
obj.cache_security_group_name = Some(StringDeserializer::deserialize(
"CacheSecurityGroupName",
stack,
)?);
}
"Description" => {
obj.description = Some(StringDeserializer::deserialize("Description", stack)?);
}
"EC2SecurityGroups" => {
obj.ec2_security_groups.get_or_insert(vec![]).extend(
EC2SecurityGroupListDeserializer::deserialize("EC2SecurityGroups", stack)?,
);
}
"OwnerId" => {
obj.owner_id = Some(StringDeserializer::deserialize("OwnerId", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct CacheSecurityGroupMembership {
pub cache_security_group_name: Option<String>,
pub status: Option<String>,
}
#[allow(dead_code)]
struct CacheSecurityGroupMembershipDeserializer;
impl CacheSecurityGroupMembershipDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CacheSecurityGroupMembership, XmlParseError> {
deserialize_elements::<_, CacheSecurityGroupMembership, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"CacheSecurityGroupName" => {
obj.cache_security_group_name = Some(StringDeserializer::deserialize(
"CacheSecurityGroupName",
stack,
)?);
}
"Status" => {
obj.status = Some(StringDeserializer::deserialize("Status", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[allow(dead_code)]
struct CacheSecurityGroupMembershipListDeserializer;
impl CacheSecurityGroupMembershipListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<CacheSecurityGroupMembership>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "CacheSecurityGroup" {
obj.push(CacheSecurityGroupMembershipDeserializer::deserialize(
"CacheSecurityGroup",
stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct CacheSecurityGroupMessage {
pub cache_security_groups: Option<Vec<CacheSecurityGroup>>,
pub marker: Option<String>,
}
#[allow(dead_code)]
struct CacheSecurityGroupMessageDeserializer;
impl CacheSecurityGroupMessageDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CacheSecurityGroupMessage, XmlParseError> {
deserialize_elements::<_, CacheSecurityGroupMessage, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"CacheSecurityGroups" => {
obj.cache_security_groups.get_or_insert(vec![]).extend(
CacheSecurityGroupsDeserializer::deserialize(
"CacheSecurityGroups",
stack,
)?,
);
}
"Marker" => {
obj.marker = Some(StringDeserializer::deserialize("Marker", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
struct CacheSecurityGroupNameListSerializer;
impl CacheSecurityGroupNameListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.member.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
#[allow(dead_code)]
struct CacheSecurityGroupsDeserializer;
impl CacheSecurityGroupsDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<CacheSecurityGroup>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "CacheSecurityGroup" {
obj.push(CacheSecurityGroupDeserializer::deserialize(
"CacheSecurityGroup",
stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct CacheSubnetGroup {
pub arn: Option<String>,
pub cache_subnet_group_description: Option<String>,
pub cache_subnet_group_name: Option<String>,
pub subnets: Option<Vec<Subnet>>,
pub vpc_id: Option<String>,
}
#[allow(dead_code)]
struct CacheSubnetGroupDeserializer;
impl CacheSubnetGroupDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CacheSubnetGroup, XmlParseError> {
deserialize_elements::<_, CacheSubnetGroup, _>(tag_name, stack, |name, stack, obj| {
match name {
"ARN" => {
obj.arn = Some(StringDeserializer::deserialize("ARN", stack)?);
}
"CacheSubnetGroupDescription" => {
obj.cache_subnet_group_description = Some(StringDeserializer::deserialize(
"CacheSubnetGroupDescription",
stack,
)?);
}
"CacheSubnetGroupName" => {
obj.cache_subnet_group_name = Some(StringDeserializer::deserialize(
"CacheSubnetGroupName",
stack,
)?);
}
"Subnets" => {
obj.subnets
.get_or_insert(vec![])
.extend(SubnetListDeserializer::deserialize("Subnets", stack)?);
}
"VpcId" => {
obj.vpc_id = Some(StringDeserializer::deserialize("VpcId", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct CacheSubnetGroupMessage {
pub cache_subnet_groups: Option<Vec<CacheSubnetGroup>>,
pub marker: Option<String>,
}
#[allow(dead_code)]
struct CacheSubnetGroupMessageDeserializer;
impl CacheSubnetGroupMessageDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CacheSubnetGroupMessage, XmlParseError> {
deserialize_elements::<_, CacheSubnetGroupMessage, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"CacheSubnetGroups" => {
obj.cache_subnet_groups.get_or_insert(vec![]).extend(
CacheSubnetGroupsDeserializer::deserialize("CacheSubnetGroups", stack)?,
);
}
"Marker" => {
obj.marker = Some(StringDeserializer::deserialize("Marker", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[allow(dead_code)]
struct CacheSubnetGroupsDeserializer;
impl CacheSubnetGroupsDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<CacheSubnetGroup>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "CacheSubnetGroup" {
obj.push(CacheSubnetGroupDeserializer::deserialize(
"CacheSubnetGroup",
stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[allow(dead_code)]
struct ChangeTypeDeserializer;
impl ChangeTypeDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct ClusterIdListDeserializer;
impl ClusterIdListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<String>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "ClusterId" {
obj.push(StringDeserializer::deserialize("ClusterId", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CompleteMigrationMessage {
pub force: Option<bool>,
pub replication_group_id: String,
}
struct CompleteMigrationMessageSerializer;
impl CompleteMigrationMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CompleteMigrationMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.force {
params.put(&format!("{}{}", prefix, "Force"), &field_value);
}
params.put(
&format!("{}{}", prefix, "ReplicationGroupId"),
&obj.replication_group_id,
);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct CompleteMigrationResponse {
pub replication_group: Option<ReplicationGroup>,
}
#[allow(dead_code)]
struct CompleteMigrationResponseDeserializer;
impl CompleteMigrationResponseDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CompleteMigrationResponse, XmlParseError> {
deserialize_elements::<_, CompleteMigrationResponse, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"ReplicationGroup" => {
obj.replication_group = Some(ReplicationGroupDeserializer::deserialize(
"ReplicationGroup",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ConfigureShard {
pub new_replica_count: i64,
pub node_group_id: String,
pub preferred_availability_zones: Option<Vec<String>>,
}
struct ConfigureShardSerializer;
impl ConfigureShardSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ConfigureShard) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "NewReplicaCount"),
&obj.new_replica_count,
);
params.put(&format!("{}{}", prefix, "NodeGroupId"), &obj.node_group_id);
if let Some(ref field_value) = obj.preferred_availability_zones {
PreferredAvailabilityZoneListSerializer::serialize(
params,
&format!("{}{}", prefix, "PreferredAvailabilityZone"),
field_value,
);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CopySnapshotMessage {
pub kms_key_id: Option<String>,
pub source_snapshot_name: String,
pub target_bucket: Option<String>,
pub target_snapshot_name: String,
}
struct CopySnapshotMessageSerializer;
impl CopySnapshotMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CopySnapshotMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.kms_key_id {
params.put(&format!("{}{}", prefix, "KmsKeyId"), &field_value);
}
params.put(
&format!("{}{}", prefix, "SourceSnapshotName"),
&obj.source_snapshot_name,
);
if let Some(ref field_value) = obj.target_bucket {
params.put(&format!("{}{}", prefix, "TargetBucket"), &field_value);
}
params.put(
&format!("{}{}", prefix, "TargetSnapshotName"),
&obj.target_snapshot_name,
);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct CopySnapshotResult {
pub snapshot: Option<Snapshot>,
}
#[allow(dead_code)]
struct CopySnapshotResultDeserializer;
impl CopySnapshotResultDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CopySnapshotResult, XmlParseError> {
deserialize_elements::<_, CopySnapshotResult, _>(tag_name, stack, |name, stack, obj| {
match name {
"Snapshot" => {
obj.snapshot = Some(SnapshotDeserializer::deserialize("Snapshot", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateCacheClusterMessage {
pub az_mode: Option<String>,
pub auth_token: Option<String>,
pub auto_minor_version_upgrade: Option<bool>,
pub cache_cluster_id: String,
pub cache_node_type: Option<String>,
pub cache_parameter_group_name: Option<String>,
pub cache_security_group_names: Option<Vec<String>>,
pub cache_subnet_group_name: Option<String>,
pub engine: Option<String>,
pub engine_version: Option<String>,
pub notification_topic_arn: Option<String>,
pub num_cache_nodes: Option<i64>,
pub port: Option<i64>,
pub preferred_availability_zone: Option<String>,
pub preferred_availability_zones: Option<Vec<String>>,
pub preferred_maintenance_window: Option<String>,
pub replication_group_id: Option<String>,
pub security_group_ids: Option<Vec<String>>,
pub snapshot_arns: Option<Vec<String>>,
pub snapshot_name: Option<String>,
pub snapshot_retention_limit: Option<i64>,
pub snapshot_window: Option<String>,
pub tags: Option<Vec<Tag>>,
}
struct CreateCacheClusterMessageSerializer;
impl CreateCacheClusterMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CreateCacheClusterMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.az_mode {
params.put(&format!("{}{}", prefix, "AZMode"), &field_value);
}
if let Some(ref field_value) = obj.auth_token {
params.put(&format!("{}{}", prefix, "AuthToken"), &field_value);
}
if let Some(ref field_value) = obj.auto_minor_version_upgrade {
params.put(
&format!("{}{}", prefix, "AutoMinorVersionUpgrade"),
&field_value,
);
}
params.put(
&format!("{}{}", prefix, "CacheClusterId"),
&obj.cache_cluster_id,
);
if let Some(ref field_value) = obj.cache_node_type {
params.put(&format!("{}{}", prefix, "CacheNodeType"), &field_value);
}
if let Some(ref field_value) = obj.cache_parameter_group_name {
params.put(
&format!("{}{}", prefix, "CacheParameterGroupName"),
&field_value,
);
}
if let Some(ref field_value) = obj.cache_security_group_names {
CacheSecurityGroupNameListSerializer::serialize(
params,
&format!("{}{}", prefix, "CacheSecurityGroupName"),
field_value,
);
}
if let Some(ref field_value) = obj.cache_subnet_group_name {
params.put(
&format!("{}{}", prefix, "CacheSubnetGroupName"),
&field_value,
);
}
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.notification_topic_arn {
params.put(
&format!("{}{}", prefix, "NotificationTopicArn"),
&field_value,
);
}
if let Some(ref field_value) = obj.num_cache_nodes {
params.put(&format!("{}{}", prefix, "NumCacheNodes"), &field_value);
}
if let Some(ref field_value) = obj.port {
params.put(&format!("{}{}", prefix, "Port"), &field_value);
}
if let Some(ref field_value) = obj.preferred_availability_zone {
params.put(
&format!("{}{}", prefix, "PreferredAvailabilityZone"),
&field_value,
);
}
if let Some(ref field_value) = obj.preferred_availability_zones {
PreferredAvailabilityZoneListSerializer::serialize(
params,
&format!("{}{}", prefix, "PreferredAvailabilityZone"),
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_group_id {
params.put(&format!("{}{}", prefix, "ReplicationGroupId"), &field_value);
}
if let Some(ref field_value) = obj.security_group_ids {
SecurityGroupIdsListSerializer::serialize(
params,
&format!("{}{}", prefix, "SecurityGroupId"),
field_value,
);
}
if let Some(ref field_value) = obj.snapshot_arns {
SnapshotArnsListSerializer::serialize(
params,
&format!("{}{}", prefix, "SnapshotArn"),
field_value,
);
}
if let Some(ref field_value) = obj.snapshot_name {
params.put(&format!("{}{}", prefix, "SnapshotName"), &field_value);
}
if let Some(ref field_value) = obj.snapshot_retention_limit {
params.put(
&format!("{}{}", prefix, "SnapshotRetentionLimit"),
&field_value,
);
}
if let Some(ref field_value) = obj.snapshot_window {
params.put(&format!("{}{}", prefix, "SnapshotWindow"), &field_value);
}
if let Some(ref field_value) = obj.tags {
TagListSerializer::serialize(params, &format!("{}{}", prefix, "Tag"), field_value);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct CreateCacheClusterResult {
pub cache_cluster: Option<CacheCluster>,
}
#[allow(dead_code)]
struct CreateCacheClusterResultDeserializer;
impl CreateCacheClusterResultDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CreateCacheClusterResult, XmlParseError> {
deserialize_elements::<_, CreateCacheClusterResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"CacheCluster" => {
obj.cache_cluster = Some(CacheClusterDeserializer::deserialize(
"CacheCluster",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateCacheParameterGroupMessage {
pub cache_parameter_group_family: String,
pub cache_parameter_group_name: String,
pub description: String,
}
struct CreateCacheParameterGroupMessageSerializer;
impl CreateCacheParameterGroupMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CreateCacheParameterGroupMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "CacheParameterGroupFamily"),
&obj.cache_parameter_group_family,
);
params.put(
&format!("{}{}", prefix, "CacheParameterGroupName"),
&obj.cache_parameter_group_name,
);
params.put(&format!("{}{}", prefix, "Description"), &obj.description);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct CreateCacheParameterGroupResult {
pub cache_parameter_group: Option<CacheParameterGroup>,
}
#[allow(dead_code)]
struct CreateCacheParameterGroupResultDeserializer;
impl CreateCacheParameterGroupResultDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CreateCacheParameterGroupResult, XmlParseError> {
deserialize_elements::<_, CreateCacheParameterGroupResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"CacheParameterGroup" => {
obj.cache_parameter_group =
Some(CacheParameterGroupDeserializer::deserialize(
"CacheParameterGroup",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateCacheSecurityGroupMessage {
pub cache_security_group_name: String,
pub description: String,
}
struct CreateCacheSecurityGroupMessageSerializer;
impl CreateCacheSecurityGroupMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CreateCacheSecurityGroupMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "CacheSecurityGroupName"),
&obj.cache_security_group_name,
);
params.put(&format!("{}{}", prefix, "Description"), &obj.description);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct CreateCacheSecurityGroupResult {
pub cache_security_group: Option<CacheSecurityGroup>,
}
#[allow(dead_code)]
struct CreateCacheSecurityGroupResultDeserializer;
impl CreateCacheSecurityGroupResultDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CreateCacheSecurityGroupResult, XmlParseError> {
deserialize_elements::<_, CreateCacheSecurityGroupResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"CacheSecurityGroup" => {
obj.cache_security_group =
Some(CacheSecurityGroupDeserializer::deserialize(
"CacheSecurityGroup",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateCacheSubnetGroupMessage {
pub cache_subnet_group_description: String,
pub cache_subnet_group_name: String,
pub subnet_ids: Vec<String>,
}
struct CreateCacheSubnetGroupMessageSerializer;
impl CreateCacheSubnetGroupMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CreateCacheSubnetGroupMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "CacheSubnetGroupDescription"),
&obj.cache_subnet_group_description,
);
params.put(
&format!("{}{}", prefix, "CacheSubnetGroupName"),
&obj.cache_subnet_group_name,
);
SubnetIdentifierListSerializer::serialize(
params,
&format!("{}{}", prefix, "SubnetIdentifier"),
&obj.subnet_ids,
);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct CreateCacheSubnetGroupResult {
pub cache_subnet_group: Option<CacheSubnetGroup>,
}
#[allow(dead_code)]
struct CreateCacheSubnetGroupResultDeserializer;
impl CreateCacheSubnetGroupResultDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CreateCacheSubnetGroupResult, XmlParseError> {
deserialize_elements::<_, CreateCacheSubnetGroupResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"CacheSubnetGroup" => {
obj.cache_subnet_group = Some(CacheSubnetGroupDeserializer::deserialize(
"CacheSubnetGroup",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateGlobalReplicationGroupMessage {
pub global_replication_group_description: Option<String>,
pub global_replication_group_id_suffix: String,
pub primary_replication_group_id: String,
}
struct CreateGlobalReplicationGroupMessageSerializer;
impl CreateGlobalReplicationGroupMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CreateGlobalReplicationGroupMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.global_replication_group_description {
params.put(
&format!("{}{}", prefix, "GlobalReplicationGroupDescription"),
&field_value,
);
}
params.put(
&format!("{}{}", prefix, "GlobalReplicationGroupIdSuffix"),
&obj.global_replication_group_id_suffix,
);
params.put(
&format!("{}{}", prefix, "PrimaryReplicationGroupId"),
&obj.primary_replication_group_id,
);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct CreateGlobalReplicationGroupResult {
pub global_replication_group: Option<GlobalReplicationGroup>,
}
#[allow(dead_code)]
struct CreateGlobalReplicationGroupResultDeserializer;
impl CreateGlobalReplicationGroupResultDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CreateGlobalReplicationGroupResult, XmlParseError> {
deserialize_elements::<_, CreateGlobalReplicationGroupResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"GlobalReplicationGroup" => {
obj.global_replication_group =
Some(GlobalReplicationGroupDeserializer::deserialize(
"GlobalReplicationGroup",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateReplicationGroupMessage {
pub at_rest_encryption_enabled: Option<bool>,
pub auth_token: Option<String>,
pub auto_minor_version_upgrade: Option<bool>,
pub automatic_failover_enabled: Option<bool>,
pub cache_node_type: Option<String>,
pub cache_parameter_group_name: Option<String>,
pub cache_security_group_names: Option<Vec<String>>,
pub cache_subnet_group_name: Option<String>,
pub engine: Option<String>,
pub engine_version: Option<String>,
pub global_replication_group_id: Option<String>,
pub kms_key_id: Option<String>,
pub multi_az_enabled: Option<bool>,
pub node_group_configuration: Option<Vec<NodeGroupConfiguration>>,
pub notification_topic_arn: Option<String>,
pub num_cache_clusters: Option<i64>,
pub num_node_groups: Option<i64>,
pub port: Option<i64>,
pub preferred_cache_cluster_a_zs: Option<Vec<String>>,
pub preferred_maintenance_window: Option<String>,
pub primary_cluster_id: Option<String>,
pub replicas_per_node_group: Option<i64>,
pub replication_group_description: String,
pub replication_group_id: String,
pub security_group_ids: Option<Vec<String>>,
pub snapshot_arns: Option<Vec<String>>,
pub snapshot_name: Option<String>,
pub snapshot_retention_limit: Option<i64>,
pub snapshot_window: Option<String>,
pub tags: Option<Vec<Tag>>,
pub transit_encryption_enabled: Option<bool>,
}
struct CreateReplicationGroupMessageSerializer;
impl CreateReplicationGroupMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CreateReplicationGroupMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.at_rest_encryption_enabled {
params.put(
&format!("{}{}", prefix, "AtRestEncryptionEnabled"),
&field_value,
);
}
if let Some(ref field_value) = obj.auth_token {
params.put(&format!("{}{}", prefix, "AuthToken"), &field_value);
}
if let Some(ref field_value) = obj.auto_minor_version_upgrade {
params.put(
&format!("{}{}", prefix, "AutoMinorVersionUpgrade"),
&field_value,
);
}
if let Some(ref field_value) = obj.automatic_failover_enabled {
params.put(
&format!("{}{}", prefix, "AutomaticFailoverEnabled"),
&field_value,
);
}
if let Some(ref field_value) = obj.cache_node_type {
params.put(&format!("{}{}", prefix, "CacheNodeType"), &field_value);
}
if let Some(ref field_value) = obj.cache_parameter_group_name {
params.put(
&format!("{}{}", prefix, "CacheParameterGroupName"),
&field_value,
);
}
if let Some(ref field_value) = obj.cache_security_group_names {
CacheSecurityGroupNameListSerializer::serialize(
params,
&format!("{}{}", prefix, "CacheSecurityGroupName"),
field_value,
);
}
if let Some(ref field_value) = obj.cache_subnet_group_name {
params.put(
&format!("{}{}", prefix, "CacheSubnetGroupName"),
&field_value,
);
}
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.global_replication_group_id {
params.put(
&format!("{}{}", prefix, "GlobalReplicationGroupId"),
&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.multi_az_enabled {
params.put(&format!("{}{}", prefix, "MultiAZEnabled"), &field_value);
}
if let Some(ref field_value) = obj.node_group_configuration {
NodeGroupConfigurationListSerializer::serialize(
params,
&format!("{}{}", prefix, "NodeGroupConfiguration"),
field_value,
);
}
if let Some(ref field_value) = obj.notification_topic_arn {
params.put(
&format!("{}{}", prefix, "NotificationTopicArn"),
&field_value,
);
}
if let Some(ref field_value) = obj.num_cache_clusters {
params.put(&format!("{}{}", prefix, "NumCacheClusters"), &field_value);
}
if let Some(ref field_value) = obj.num_node_groups {
params.put(&format!("{}{}", prefix, "NumNodeGroups"), &field_value);
}
if let Some(ref field_value) = obj.port {
params.put(&format!("{}{}", prefix, "Port"), &field_value);
}
if let Some(ref field_value) = obj.preferred_cache_cluster_a_zs {
AvailabilityZonesListSerializer::serialize(
params,
&format!("{}{}", prefix, "AvailabilityZone"),
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.primary_cluster_id {
params.put(&format!("{}{}", prefix, "PrimaryClusterId"), &field_value);
}
if let Some(ref field_value) = obj.replicas_per_node_group {
params.put(
&format!("{}{}", prefix, "ReplicasPerNodeGroup"),
&field_value,
);
}
params.put(
&format!("{}{}", prefix, "ReplicationGroupDescription"),
&obj.replication_group_description,
);
params.put(
&format!("{}{}", prefix, "ReplicationGroupId"),
&obj.replication_group_id,
);
if let Some(ref field_value) = obj.security_group_ids {
SecurityGroupIdsListSerializer::serialize(
params,
&format!("{}{}", prefix, "SecurityGroupId"),
field_value,
);
}
if let Some(ref field_value) = obj.snapshot_arns {
SnapshotArnsListSerializer::serialize(
params,
&format!("{}{}", prefix, "SnapshotArn"),
field_value,
);
}
if let Some(ref field_value) = obj.snapshot_name {
params.put(&format!("{}{}", prefix, "SnapshotName"), &field_value);
}
if let Some(ref field_value) = obj.snapshot_retention_limit {
params.put(
&format!("{}{}", prefix, "SnapshotRetentionLimit"),
&field_value,
);
}
if let Some(ref field_value) = obj.snapshot_window {
params.put(&format!("{}{}", prefix, "SnapshotWindow"), &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.transit_encryption_enabled {
params.put(
&format!("{}{}", prefix, "TransitEncryptionEnabled"),
&field_value,
);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct CreateReplicationGroupResult {
pub replication_group: Option<ReplicationGroup>,
}
#[allow(dead_code)]
struct CreateReplicationGroupResultDeserializer;
impl CreateReplicationGroupResultDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CreateReplicationGroupResult, XmlParseError> {
deserialize_elements::<_, CreateReplicationGroupResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"ReplicationGroup" => {
obj.replication_group = Some(ReplicationGroupDeserializer::deserialize(
"ReplicationGroup",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateSnapshotMessage {
pub cache_cluster_id: Option<String>,
pub kms_key_id: Option<String>,
pub replication_group_id: Option<String>,
pub snapshot_name: String,
}
struct CreateSnapshotMessageSerializer;
impl CreateSnapshotMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CreateSnapshotMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.cache_cluster_id {
params.put(&format!("{}{}", prefix, "CacheClusterId"), &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.replication_group_id {
params.put(&format!("{}{}", prefix, "ReplicationGroupId"), &field_value);
}
params.put(&format!("{}{}", prefix, "SnapshotName"), &obj.snapshot_name);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct CreateSnapshotResult {
pub snapshot: Option<Snapshot>,
}
#[allow(dead_code)]
struct CreateSnapshotResultDeserializer;
impl CreateSnapshotResultDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CreateSnapshotResult, XmlParseError> {
deserialize_elements::<_, CreateSnapshotResult, _>(tag_name, stack, |name, stack, obj| {
match name {
"Snapshot" => {
obj.snapshot = Some(SnapshotDeserializer::deserialize("Snapshot", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CustomerNodeEndpoint {
pub address: Option<String>,
pub port: Option<i64>,
}
struct CustomerNodeEndpointSerializer;
impl CustomerNodeEndpointSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CustomerNodeEndpoint) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.address {
params.put(&format!("{}{}", prefix, "Address"), &field_value);
}
if let Some(ref field_value) = obj.port {
params.put(&format!("{}{}", prefix, "Port"), &field_value);
}
}
}
struct CustomerNodeEndpointListSerializer;
impl CustomerNodeEndpointListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<CustomerNodeEndpoint>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.member.{}", name, index + 1);
CustomerNodeEndpointSerializer::serialize(params, &key, obj);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DecreaseNodeGroupsInGlobalReplicationGroupMessage {
pub apply_immediately: bool,
pub global_node_groups_to_remove: Option<Vec<String>>,
pub global_node_groups_to_retain: Option<Vec<String>>,
pub global_replication_group_id: String,
pub node_group_count: i64,
}
struct DecreaseNodeGroupsInGlobalReplicationGroupMessageSerializer;
impl DecreaseNodeGroupsInGlobalReplicationGroupMessageSerializer {
fn serialize(
params: &mut Params,
name: &str,
obj: &DecreaseNodeGroupsInGlobalReplicationGroupMessage,
) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "ApplyImmediately"),
&obj.apply_immediately,
);
if let Some(ref field_value) = obj.global_node_groups_to_remove {
GlobalNodeGroupIdListSerializer::serialize(
params,
&format!("{}{}", prefix, "GlobalNodeGroupId"),
field_value,
);
}
if let Some(ref field_value) = obj.global_node_groups_to_retain {
GlobalNodeGroupIdListSerializer::serialize(
params,
&format!("{}{}", prefix, "GlobalNodeGroupId"),
field_value,
);
}
params.put(
&format!("{}{}", prefix, "GlobalReplicationGroupId"),
&obj.global_replication_group_id,
);
params.put(
&format!("{}{}", prefix, "NodeGroupCount"),
&obj.node_group_count,
);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct DecreaseNodeGroupsInGlobalReplicationGroupResult {
pub global_replication_group: Option<GlobalReplicationGroup>,
}
#[allow(dead_code)]
struct DecreaseNodeGroupsInGlobalReplicationGroupResultDeserializer;
impl DecreaseNodeGroupsInGlobalReplicationGroupResultDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DecreaseNodeGroupsInGlobalReplicationGroupResult, XmlParseError> {
deserialize_elements::<_, DecreaseNodeGroupsInGlobalReplicationGroupResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"GlobalReplicationGroup" => {
obj.global_replication_group =
Some(GlobalReplicationGroupDeserializer::deserialize(
"GlobalReplicationGroup",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DecreaseReplicaCountMessage {
pub apply_immediately: bool,
pub new_replica_count: Option<i64>,
pub replica_configuration: Option<Vec<ConfigureShard>>,
pub replicas_to_remove: Option<Vec<String>>,
pub replication_group_id: String,
}
struct DecreaseReplicaCountMessageSerializer;
impl DecreaseReplicaCountMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DecreaseReplicaCountMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "ApplyImmediately"),
&obj.apply_immediately,
);
if let Some(ref field_value) = obj.new_replica_count {
params.put(&format!("{}{}", prefix, "NewReplicaCount"), &field_value);
}
if let Some(ref field_value) = obj.replica_configuration {
ReplicaConfigurationListSerializer::serialize(
params,
&format!("{}{}", prefix, "ConfigureShard"),
field_value,
);
}
if let Some(ref field_value) = obj.replicas_to_remove {
RemoveReplicasListSerializer::serialize(
params,
&format!("{}{}", prefix, "ReplicasToRemove"),
field_value,
);
}
params.put(
&format!("{}{}", prefix, "ReplicationGroupId"),
&obj.replication_group_id,
);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct DecreaseReplicaCountResult {
pub replication_group: Option<ReplicationGroup>,
}
#[allow(dead_code)]
struct DecreaseReplicaCountResultDeserializer;
impl DecreaseReplicaCountResultDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DecreaseReplicaCountResult, XmlParseError> {
deserialize_elements::<_, DecreaseReplicaCountResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"ReplicationGroup" => {
obj.replication_group = Some(ReplicationGroupDeserializer::deserialize(
"ReplicationGroup",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteCacheClusterMessage {
pub cache_cluster_id: String,
pub final_snapshot_identifier: Option<String>,
}
struct DeleteCacheClusterMessageSerializer;
impl DeleteCacheClusterMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DeleteCacheClusterMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "CacheClusterId"),
&obj.cache_cluster_id,
);
if let Some(ref field_value) = obj.final_snapshot_identifier {
params.put(
&format!("{}{}", prefix, "FinalSnapshotIdentifier"),
&field_value,
);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct DeleteCacheClusterResult {
pub cache_cluster: Option<CacheCluster>,
}
#[allow(dead_code)]
struct DeleteCacheClusterResultDeserializer;
impl DeleteCacheClusterResultDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DeleteCacheClusterResult, XmlParseError> {
deserialize_elements::<_, DeleteCacheClusterResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"CacheCluster" => {
obj.cache_cluster = Some(CacheClusterDeserializer::deserialize(
"CacheCluster",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteCacheParameterGroupMessage {
pub cache_parameter_group_name: String,
}
struct DeleteCacheParameterGroupMessageSerializer;
impl DeleteCacheParameterGroupMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DeleteCacheParameterGroupMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "CacheParameterGroupName"),
&obj.cache_parameter_group_name,
);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteCacheSecurityGroupMessage {
pub cache_security_group_name: String,
}
struct DeleteCacheSecurityGroupMessageSerializer;
impl DeleteCacheSecurityGroupMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DeleteCacheSecurityGroupMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "CacheSecurityGroupName"),
&obj.cache_security_group_name,
);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteCacheSubnetGroupMessage {
pub cache_subnet_group_name: String,
}
struct DeleteCacheSubnetGroupMessageSerializer;
impl DeleteCacheSubnetGroupMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DeleteCacheSubnetGroupMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "CacheSubnetGroupName"),
&obj.cache_subnet_group_name,
);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteGlobalReplicationGroupMessage {
pub global_replication_group_id: String,
pub retain_primary_replication_group: bool,
}
struct DeleteGlobalReplicationGroupMessageSerializer;
impl DeleteGlobalReplicationGroupMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DeleteGlobalReplicationGroupMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "GlobalReplicationGroupId"),
&obj.global_replication_group_id,
);
params.put(
&format!("{}{}", prefix, "RetainPrimaryReplicationGroup"),
&obj.retain_primary_replication_group,
);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct DeleteGlobalReplicationGroupResult {
pub global_replication_group: Option<GlobalReplicationGroup>,
}
#[allow(dead_code)]
struct DeleteGlobalReplicationGroupResultDeserializer;
impl DeleteGlobalReplicationGroupResultDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DeleteGlobalReplicationGroupResult, XmlParseError> {
deserialize_elements::<_, DeleteGlobalReplicationGroupResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"GlobalReplicationGroup" => {
obj.global_replication_group =
Some(GlobalReplicationGroupDeserializer::deserialize(
"GlobalReplicationGroup",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteReplicationGroupMessage {
pub final_snapshot_identifier: Option<String>,
pub replication_group_id: String,
pub retain_primary_cluster: Option<bool>,
}
struct DeleteReplicationGroupMessageSerializer;
impl DeleteReplicationGroupMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DeleteReplicationGroupMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.final_snapshot_identifier {
params.put(
&format!("{}{}", prefix, "FinalSnapshotIdentifier"),
&field_value,
);
}
params.put(
&format!("{}{}", prefix, "ReplicationGroupId"),
&obj.replication_group_id,
);
if let Some(ref field_value) = obj.retain_primary_cluster {
params.put(
&format!("{}{}", prefix, "RetainPrimaryCluster"),
&field_value,
);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct DeleteReplicationGroupResult {
pub replication_group: Option<ReplicationGroup>,
}
#[allow(dead_code)]
struct DeleteReplicationGroupResultDeserializer;
impl DeleteReplicationGroupResultDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DeleteReplicationGroupResult, XmlParseError> {
deserialize_elements::<_, DeleteReplicationGroupResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"ReplicationGroup" => {
obj.replication_group = Some(ReplicationGroupDeserializer::deserialize(
"ReplicationGroup",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteSnapshotMessage {
pub snapshot_name: String,
}
struct DeleteSnapshotMessageSerializer;
impl DeleteSnapshotMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DeleteSnapshotMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(&format!("{}{}", prefix, "SnapshotName"), &obj.snapshot_name);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct DeleteSnapshotResult {
pub snapshot: Option<Snapshot>,
}
#[allow(dead_code)]
struct DeleteSnapshotResultDeserializer;
impl DeleteSnapshotResultDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DeleteSnapshotResult, XmlParseError> {
deserialize_elements::<_, DeleteSnapshotResult, _>(tag_name, stack, |name, stack, obj| {
match name {
"Snapshot" => {
obj.snapshot = Some(SnapshotDeserializer::deserialize("Snapshot", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeCacheClustersMessage {
pub cache_cluster_id: Option<String>,
pub marker: Option<String>,
pub max_records: Option<i64>,
pub show_cache_clusters_not_in_replication_groups: Option<bool>,
pub show_cache_node_info: Option<bool>,
}
struct DescribeCacheClustersMessageSerializer;
impl DescribeCacheClustersMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeCacheClustersMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.cache_cluster_id {
params.put(&format!("{}{}", prefix, "CacheClusterId"), &field_value);
}
if let Some(ref field_value) = obj.marker {
params.put(&format!("{}{}", prefix, "Marker"), &field_value);
}
if let Some(ref field_value) = obj.max_records {
params.put(&format!("{}{}", prefix, "MaxRecords"), &field_value);
}
if let Some(ref field_value) = obj.show_cache_clusters_not_in_replication_groups {
params.put(
&format!("{}{}", prefix, "ShowCacheClustersNotInReplicationGroups"),
&field_value,
);
}
if let Some(ref field_value) = obj.show_cache_node_info {
params.put(&format!("{}{}", prefix, "ShowCacheNodeInfo"), &field_value);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeCacheEngineVersionsMessage {
pub cache_parameter_group_family: Option<String>,
pub default_only: Option<bool>,
pub engine: Option<String>,
pub engine_version: Option<String>,
pub marker: Option<String>,
pub max_records: Option<i64>,
}
struct DescribeCacheEngineVersionsMessageSerializer;
impl DescribeCacheEngineVersionsMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeCacheEngineVersionsMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.cache_parameter_group_family {
params.put(
&format!("{}{}", prefix, "CacheParameterGroupFamily"),
&field_value,
);
}
if let Some(ref field_value) = obj.default_only {
params.put(&format!("{}{}", prefix, "DefaultOnly"), &field_value);
}
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.marker {
params.put(&format!("{}{}", prefix, "Marker"), &field_value);
}
if let Some(ref field_value) = obj.max_records {
params.put(&format!("{}{}", prefix, "MaxRecords"), &field_value);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeCacheParameterGroupsMessage {
pub cache_parameter_group_name: Option<String>,
pub marker: Option<String>,
pub max_records: Option<i64>,
}
struct DescribeCacheParameterGroupsMessageSerializer;
impl DescribeCacheParameterGroupsMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeCacheParameterGroupsMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.cache_parameter_group_name {
params.put(
&format!("{}{}", prefix, "CacheParameterGroupName"),
&field_value,
);
}
if let Some(ref field_value) = obj.marker {
params.put(&format!("{}{}", prefix, "Marker"), &field_value);
}
if let Some(ref field_value) = obj.max_records {
params.put(&format!("{}{}", prefix, "MaxRecords"), &field_value);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeCacheParametersMessage {
pub cache_parameter_group_name: String,
pub marker: Option<String>,
pub max_records: Option<i64>,
pub source: Option<String>,
}
struct DescribeCacheParametersMessageSerializer;
impl DescribeCacheParametersMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeCacheParametersMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "CacheParameterGroupName"),
&obj.cache_parameter_group_name,
);
if let Some(ref field_value) = obj.marker {
params.put(&format!("{}{}", prefix, "Marker"), &field_value);
}
if let Some(ref field_value) = obj.max_records {
params.put(&format!("{}{}", prefix, "MaxRecords"), &field_value);
}
if let Some(ref field_value) = obj.source {
params.put(&format!("{}{}", prefix, "Source"), &field_value);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeCacheSecurityGroupsMessage {
pub cache_security_group_name: Option<String>,
pub marker: Option<String>,
pub max_records: Option<i64>,
}
struct DescribeCacheSecurityGroupsMessageSerializer;
impl DescribeCacheSecurityGroupsMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeCacheSecurityGroupsMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.cache_security_group_name {
params.put(
&format!("{}{}", prefix, "CacheSecurityGroupName"),
&field_value,
);
}
if let Some(ref field_value) = obj.marker {
params.put(&format!("{}{}", prefix, "Marker"), &field_value);
}
if let Some(ref field_value) = obj.max_records {
params.put(&format!("{}{}", prefix, "MaxRecords"), &field_value);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeCacheSubnetGroupsMessage {
pub cache_subnet_group_name: Option<String>,
pub marker: Option<String>,
pub max_records: Option<i64>,
}
struct DescribeCacheSubnetGroupsMessageSerializer;
impl DescribeCacheSubnetGroupsMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeCacheSubnetGroupsMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.cache_subnet_group_name {
params.put(
&format!("{}{}", prefix, "CacheSubnetGroupName"),
&field_value,
);
}
if let Some(ref field_value) = obj.marker {
params.put(&format!("{}{}", prefix, "Marker"), &field_value);
}
if let Some(ref field_value) = obj.max_records {
params.put(&format!("{}{}", prefix, "MaxRecords"), &field_value);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeEngineDefaultParametersMessage {
pub cache_parameter_group_family: String,
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, "CacheParameterGroupFamily"),
&obj.cache_parameter_group_family,
);
if let Some(ref field_value) = obj.marker {
params.put(&format!("{}{}", prefix, "Marker"), &field_value);
}
if let Some(ref field_value) = obj.max_records {
params.put(&format!("{}{}", prefix, "MaxRecords"), &field_value);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct DescribeEngineDefaultParametersResult {
pub engine_defaults: Option<EngineDefaults>,
}
#[allow(dead_code)]
struct DescribeEngineDefaultParametersResultDeserializer;
impl DescribeEngineDefaultParametersResultDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeEngineDefaultParametersResult, XmlParseError> {
deserialize_elements::<_, DescribeEngineDefaultParametersResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"EngineDefaults" => {
obj.engine_defaults = Some(EngineDefaultsDeserializer::deserialize(
"EngineDefaults",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeEventsMessage {
pub duration: Option<i64>,
pub end_time: Option<String>,
pub marker: Option<String>,
pub max_records: Option<i64>,
pub source_identifier: Option<String>,
pub source_type: Option<String>,
pub start_time: Option<String>,
}
struct DescribeEventsMessageSerializer;
impl DescribeEventsMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeEventsMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.duration {
params.put(&format!("{}{}", prefix, "Duration"), &field_value);
}
if let Some(ref field_value) = obj.end_time {
params.put(&format!("{}{}", prefix, "EndTime"), &field_value);
}
if let Some(ref field_value) = obj.marker {
params.put(&format!("{}{}", prefix, "Marker"), &field_value);
}
if let Some(ref field_value) = obj.max_records {
params.put(&format!("{}{}", prefix, "MaxRecords"), &field_value);
}
if let Some(ref field_value) = obj.source_identifier {
params.put(&format!("{}{}", prefix, "SourceIdentifier"), &field_value);
}
if let Some(ref field_value) = obj.source_type {
params.put(&format!("{}{}", prefix, "SourceType"), &field_value);
}
if let Some(ref field_value) = obj.start_time {
params.put(&format!("{}{}", prefix, "StartTime"), &field_value);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeGlobalReplicationGroupsMessage {
pub global_replication_group_id: Option<String>,
pub marker: Option<String>,
pub max_records: Option<i64>,
pub show_member_info: Option<bool>,
}
struct DescribeGlobalReplicationGroupsMessageSerializer;
impl DescribeGlobalReplicationGroupsMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeGlobalReplicationGroupsMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.global_replication_group_id {
params.put(
&format!("{}{}", prefix, "GlobalReplicationGroupId"),
&field_value,
);
}
if let Some(ref field_value) = obj.marker {
params.put(&format!("{}{}", prefix, "Marker"), &field_value);
}
if let Some(ref field_value) = obj.max_records {
params.put(&format!("{}{}", prefix, "MaxRecords"), &field_value);
}
if let Some(ref field_value) = obj.show_member_info {
params.put(&format!("{}{}", prefix, "ShowMemberInfo"), &field_value);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct DescribeGlobalReplicationGroupsResult {
pub global_replication_groups: Option<Vec<GlobalReplicationGroup>>,
pub marker: Option<String>,
}
#[allow(dead_code)]
struct DescribeGlobalReplicationGroupsResultDeserializer;
impl DescribeGlobalReplicationGroupsResultDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeGlobalReplicationGroupsResult, XmlParseError> {
deserialize_elements::<_, DescribeGlobalReplicationGroupsResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"GlobalReplicationGroups" => {
obj.global_replication_groups.get_or_insert(vec![]).extend(
GlobalReplicationGroupListDeserializer::deserialize(
"GlobalReplicationGroups",
stack,
)?,
);
}
"Marker" => {
obj.marker = Some(StringDeserializer::deserialize("Marker", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeReplicationGroupsMessage {
pub marker: Option<String>,
pub max_records: Option<i64>,
pub replication_group_id: Option<String>,
}
struct DescribeReplicationGroupsMessageSerializer;
impl DescribeReplicationGroupsMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeReplicationGroupsMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.marker {
params.put(&format!("{}{}", prefix, "Marker"), &field_value);
}
if let Some(ref field_value) = obj.max_records {
params.put(&format!("{}{}", prefix, "MaxRecords"), &field_value);
}
if let Some(ref field_value) = obj.replication_group_id {
params.put(&format!("{}{}", prefix, "ReplicationGroupId"), &field_value);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeReservedCacheNodesMessage {
pub cache_node_type: Option<String>,
pub duration: Option<String>,
pub marker: Option<String>,
pub max_records: Option<i64>,
pub offering_type: Option<String>,
pub product_description: Option<String>,
pub reserved_cache_node_id: Option<String>,
pub reserved_cache_nodes_offering_id: Option<String>,
}
struct DescribeReservedCacheNodesMessageSerializer;
impl DescribeReservedCacheNodesMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeReservedCacheNodesMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.cache_node_type {
params.put(&format!("{}{}", prefix, "CacheNodeType"), &field_value);
}
if let Some(ref field_value) = obj.duration {
params.put(&format!("{}{}", prefix, "Duration"), &field_value);
}
if let Some(ref field_value) = obj.marker {
params.put(&format!("{}{}", prefix, "Marker"), &field_value);
}
if let Some(ref field_value) = obj.max_records {
params.put(&format!("{}{}", prefix, "MaxRecords"), &field_value);
}
if let Some(ref field_value) = obj.offering_type {
params.put(&format!("{}{}", prefix, "OfferingType"), &field_value);
}
if let Some(ref field_value) = obj.product_description {
params.put(&format!("{}{}", prefix, "ProductDescription"), &field_value);
}
if let Some(ref field_value) = obj.reserved_cache_node_id {
params.put(
&format!("{}{}", prefix, "ReservedCacheNodeId"),
&field_value,
);
}
if let Some(ref field_value) = obj.reserved_cache_nodes_offering_id {
params.put(
&format!("{}{}", prefix, "ReservedCacheNodesOfferingId"),
&field_value,
);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeReservedCacheNodesOfferingsMessage {
pub cache_node_type: Option<String>,
pub duration: Option<String>,
pub marker: Option<String>,
pub max_records: Option<i64>,
pub offering_type: Option<String>,
pub product_description: Option<String>,
pub reserved_cache_nodes_offering_id: Option<String>,
}
struct DescribeReservedCacheNodesOfferingsMessageSerializer;
impl DescribeReservedCacheNodesOfferingsMessageSerializer {
fn serialize(
params: &mut Params,
name: &str,
obj: &DescribeReservedCacheNodesOfferingsMessage,
) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.cache_node_type {
params.put(&format!("{}{}", prefix, "CacheNodeType"), &field_value);
}
if let Some(ref field_value) = obj.duration {
params.put(&format!("{}{}", prefix, "Duration"), &field_value);
}
if let Some(ref field_value) = obj.marker {
params.put(&format!("{}{}", prefix, "Marker"), &field_value);
}
if let Some(ref field_value) = obj.max_records {
params.put(&format!("{}{}", prefix, "MaxRecords"), &field_value);
}
if let Some(ref field_value) = obj.offering_type {
params.put(&format!("{}{}", prefix, "OfferingType"), &field_value);
}
if let Some(ref field_value) = obj.product_description {
params.put(&format!("{}{}", prefix, "ProductDescription"), &field_value);
}
if let Some(ref field_value) = obj.reserved_cache_nodes_offering_id {
params.put(
&format!("{}{}", prefix, "ReservedCacheNodesOfferingId"),
&field_value,
);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeServiceUpdatesMessage {
pub marker: Option<String>,
pub max_records: Option<i64>,
pub service_update_name: Option<String>,
pub service_update_status: Option<Vec<String>>,
}
struct DescribeServiceUpdatesMessageSerializer;
impl DescribeServiceUpdatesMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeServiceUpdatesMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.marker {
params.put(&format!("{}{}", prefix, "Marker"), &field_value);
}
if let Some(ref field_value) = obj.max_records {
params.put(&format!("{}{}", prefix, "MaxRecords"), &field_value);
}
if let Some(ref field_value) = obj.service_update_name {
params.put(&format!("{}{}", prefix, "ServiceUpdateName"), &field_value);
}
if let Some(ref field_value) = obj.service_update_status {
ServiceUpdateStatusListSerializer::serialize(
params,
&format!("{}{}", prefix, "ServiceUpdateStatus"),
field_value,
);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct DescribeSnapshotsListMessage {
pub marker: Option<String>,
pub snapshots: Option<Vec<Snapshot>>,
}
#[allow(dead_code)]
struct DescribeSnapshotsListMessageDeserializer;
impl DescribeSnapshotsListMessageDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DescribeSnapshotsListMessage, XmlParseError> {
deserialize_elements::<_, DescribeSnapshotsListMessage, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"Marker" => {
obj.marker = Some(StringDeserializer::deserialize("Marker", stack)?);
}
"Snapshots" => {
obj.snapshots
.get_or_insert(vec![])
.extend(SnapshotListDeserializer::deserialize("Snapshots", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeSnapshotsMessage {
pub cache_cluster_id: Option<String>,
pub marker: Option<String>,
pub max_records: Option<i64>,
pub replication_group_id: Option<String>,
pub show_node_group_config: Option<bool>,
pub snapshot_name: Option<String>,
pub snapshot_source: Option<String>,
}
struct DescribeSnapshotsMessageSerializer;
impl DescribeSnapshotsMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeSnapshotsMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.cache_cluster_id {
params.put(&format!("{}{}", prefix, "CacheClusterId"), &field_value);
}
if let Some(ref field_value) = obj.marker {
params.put(&format!("{}{}", prefix, "Marker"), &field_value);
}
if let Some(ref field_value) = obj.max_records {
params.put(&format!("{}{}", prefix, "MaxRecords"), &field_value);
}
if let Some(ref field_value) = obj.replication_group_id {
params.put(&format!("{}{}", prefix, "ReplicationGroupId"), &field_value);
}
if let Some(ref field_value) = obj.show_node_group_config {
params.put(
&format!("{}{}", prefix, "ShowNodeGroupConfig"),
&field_value,
);
}
if let Some(ref field_value) = obj.snapshot_name {
params.put(&format!("{}{}", prefix, "SnapshotName"), &field_value);
}
if let Some(ref field_value) = obj.snapshot_source {
params.put(&format!("{}{}", prefix, "SnapshotSource"), &field_value);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeUpdateActionsMessage {
pub cache_cluster_ids: Option<Vec<String>>,
pub engine: Option<String>,
pub marker: Option<String>,
pub max_records: Option<i64>,
pub replication_group_ids: Option<Vec<String>>,
pub service_update_name: Option<String>,
pub service_update_status: Option<Vec<String>>,
pub service_update_time_range: Option<TimeRangeFilter>,
pub show_node_level_update_status: Option<bool>,
pub update_action_status: Option<Vec<String>>,
}
struct DescribeUpdateActionsMessageSerializer;
impl DescribeUpdateActionsMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DescribeUpdateActionsMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.cache_cluster_ids {
CacheClusterIdListSerializer::serialize(
params,
&format!("{}{}", prefix, "CacheClusterIds"),
field_value,
);
}
if let Some(ref field_value) = obj.engine {
params.put(&format!("{}{}", prefix, "Engine"), &field_value);
}
if let Some(ref field_value) = obj.marker {
params.put(&format!("{}{}", prefix, "Marker"), &field_value);
}
if let Some(ref field_value) = obj.max_records {
params.put(&format!("{}{}", prefix, "MaxRecords"), &field_value);
}
if let Some(ref field_value) = obj.replication_group_ids {
ReplicationGroupIdListSerializer::serialize(
params,
&format!("{}{}", prefix, "ReplicationGroupIds"),
field_value,
);
}
if let Some(ref field_value) = obj.service_update_name {
params.put(&format!("{}{}", prefix, "ServiceUpdateName"), &field_value);
}
if let Some(ref field_value) = obj.service_update_status {
ServiceUpdateStatusListSerializer::serialize(
params,
&format!("{}{}", prefix, "ServiceUpdateStatus"),
field_value,
);
}
if let Some(ref field_value) = obj.service_update_time_range {
TimeRangeFilterSerializer::serialize(
params,
&format!("{}{}", prefix, "ServiceUpdateTimeRange"),
field_value,
);
}
if let Some(ref field_value) = obj.show_node_level_update_status {
params.put(
&format!("{}{}", prefix, "ShowNodeLevelUpdateStatus"),
&field_value,
);
}
if let Some(ref field_value) = obj.update_action_status {
UpdateActionStatusListSerializer::serialize(
params,
&format!("{}{}", prefix, "UpdateActionStatus"),
field_value,
);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DisassociateGlobalReplicationGroupMessage {
pub global_replication_group_id: String,
pub replication_group_id: String,
pub replication_group_region: String,
}
struct DisassociateGlobalReplicationGroupMessageSerializer;
impl DisassociateGlobalReplicationGroupMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DisassociateGlobalReplicationGroupMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "GlobalReplicationGroupId"),
&obj.global_replication_group_id,
);
params.put(
&format!("{}{}", prefix, "ReplicationGroupId"),
&obj.replication_group_id,
);
params.put(
&format!("{}{}", prefix, "ReplicationGroupRegion"),
&obj.replication_group_region,
);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct DisassociateGlobalReplicationGroupResult {
pub global_replication_group: Option<GlobalReplicationGroup>,
}
#[allow(dead_code)]
struct DisassociateGlobalReplicationGroupResultDeserializer;
impl DisassociateGlobalReplicationGroupResultDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DisassociateGlobalReplicationGroupResult, XmlParseError> {
deserialize_elements::<_, DisassociateGlobalReplicationGroupResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"GlobalReplicationGroup" => {
obj.global_replication_group =
Some(GlobalReplicationGroupDeserializer::deserialize(
"GlobalReplicationGroup",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[allow(dead_code)]
struct DoubleDeserializer;
impl DoubleDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<f64, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, |s| Ok(f64::from_str(&s).unwrap()))
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct EC2SecurityGroup {
pub ec2_security_group_name: Option<String>,
pub ec2_security_group_owner_id: Option<String>,
pub status: Option<String>,
}
#[allow(dead_code)]
struct EC2SecurityGroupDeserializer;
impl EC2SecurityGroupDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<EC2SecurityGroup, XmlParseError> {
deserialize_elements::<_, EC2SecurityGroup, _>(tag_name, stack, |name, stack, obj| {
match name {
"EC2SecurityGroupName" => {
obj.ec2_security_group_name = Some(StringDeserializer::deserialize(
"EC2SecurityGroupName",
stack,
)?);
}
"EC2SecurityGroupOwnerId" => {
obj.ec2_security_group_owner_id = Some(StringDeserializer::deserialize(
"EC2SecurityGroupOwnerId",
stack,
)?);
}
"Status" => {
obj.status = Some(StringDeserializer::deserialize("Status", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[allow(dead_code)]
struct EC2SecurityGroupListDeserializer;
impl EC2SecurityGroupListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<EC2SecurityGroup>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "EC2SecurityGroup" {
obj.push(EC2SecurityGroupDeserializer::deserialize(
"EC2SecurityGroup",
stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct Endpoint {
pub address: Option<String>,
pub port: Option<i64>,
}
#[allow(dead_code)]
struct EndpointDeserializer;
impl EndpointDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Endpoint, XmlParseError> {
deserialize_elements::<_, Endpoint, _>(tag_name, stack, |name, stack, obj| {
match name {
"Address" => {
obj.address = Some(StringDeserializer::deserialize("Address", stack)?);
}
"Port" => {
obj.port = Some(IntegerDeserializer::deserialize("Port", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct EngineDefaults {
pub cache_node_type_specific_parameters: Option<Vec<CacheNodeTypeSpecificParameter>>,
pub cache_parameter_group_family: Option<String>,
pub marker: Option<String>,
pub parameters: Option<Vec<Parameter>>,
}
#[allow(dead_code)]
struct EngineDefaultsDeserializer;
impl EngineDefaultsDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<EngineDefaults, XmlParseError> {
deserialize_elements::<_, EngineDefaults, _>(tag_name, stack, |name, stack, obj| {
match name {
"CacheNodeTypeSpecificParameters" => {
obj.cache_node_type_specific_parameters
.get_or_insert(vec![])
.extend(
CacheNodeTypeSpecificParametersListDeserializer::deserialize(
"CacheNodeTypeSpecificParameters",
stack,
)?,
);
}
"CacheParameterGroupFamily" => {
obj.cache_parameter_group_family = Some(StringDeserializer::deserialize(
"CacheParameterGroupFamily",
stack,
)?);
}
"Marker" => {
obj.marker = Some(StringDeserializer::deserialize("Marker", stack)?);
}
"Parameters" => {
obj.parameters.get_or_insert(vec![]).extend(
ParametersListDeserializer::deserialize("Parameters", stack)?,
);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct Event {
pub date: Option<String>,
pub message: Option<String>,
pub source_identifier: Option<String>,
pub source_type: Option<String>,
}
#[allow(dead_code)]
struct EventDeserializer;
impl EventDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<Event, XmlParseError> {
deserialize_elements::<_, Event, _>(tag_name, stack, |name, stack, obj| {
match name {
"Date" => {
obj.date = Some(TStampDeserializer::deserialize("Date", stack)?);
}
"Message" => {
obj.message = Some(StringDeserializer::deserialize("Message", stack)?);
}
"SourceIdentifier" => {
obj.source_identifier =
Some(StringDeserializer::deserialize("SourceIdentifier", stack)?);
}
"SourceType" => {
obj.source_type =
Some(SourceTypeDeserializer::deserialize("SourceType", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[allow(dead_code)]
struct EventListDeserializer;
impl EventListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<Event>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "Event" {
obj.push(EventDeserializer::deserialize("Event", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct EventsMessage {
pub events: Option<Vec<Event>>,
pub marker: Option<String>,
}
#[allow(dead_code)]
struct EventsMessageDeserializer;
impl EventsMessageDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<EventsMessage, XmlParseError> {
deserialize_elements::<_, EventsMessage, _>(tag_name, stack, |name, stack, obj| {
match name {
"Events" => {
obj.events
.get_or_insert(vec![])
.extend(EventListDeserializer::deserialize("Events", stack)?);
}
"Marker" => {
obj.marker = Some(StringDeserializer::deserialize("Marker", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct FailoverGlobalReplicationGroupMessage {
pub global_replication_group_id: String,
pub primary_region: String,
pub primary_replication_group_id: String,
}
struct FailoverGlobalReplicationGroupMessageSerializer;
impl FailoverGlobalReplicationGroupMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &FailoverGlobalReplicationGroupMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "GlobalReplicationGroupId"),
&obj.global_replication_group_id,
);
params.put(
&format!("{}{}", prefix, "PrimaryRegion"),
&obj.primary_region,
);
params.put(
&format!("{}{}", prefix, "PrimaryReplicationGroupId"),
&obj.primary_replication_group_id,
);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct FailoverGlobalReplicationGroupResult {
pub global_replication_group: Option<GlobalReplicationGroup>,
}
#[allow(dead_code)]
struct FailoverGlobalReplicationGroupResultDeserializer;
impl FailoverGlobalReplicationGroupResultDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<FailoverGlobalReplicationGroupResult, XmlParseError> {
deserialize_elements::<_, FailoverGlobalReplicationGroupResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"GlobalReplicationGroup" => {
obj.global_replication_group =
Some(GlobalReplicationGroupDeserializer::deserialize(
"GlobalReplicationGroup",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct GlobalNodeGroup {
pub global_node_group_id: Option<String>,
pub slots: Option<String>,
}
#[allow(dead_code)]
struct GlobalNodeGroupDeserializer;
impl GlobalNodeGroupDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<GlobalNodeGroup, XmlParseError> {
deserialize_elements::<_, GlobalNodeGroup, _>(tag_name, stack, |name, stack, obj| {
match name {
"GlobalNodeGroupId" => {
obj.global_node_group_id =
Some(StringDeserializer::deserialize("GlobalNodeGroupId", stack)?);
}
"Slots" => {
obj.slots = Some(StringDeserializer::deserialize("Slots", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct GlobalNodeGroupIdListSerializer;
impl GlobalNodeGroupIdListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.member.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
#[allow(dead_code)]
struct GlobalNodeGroupListDeserializer;
impl GlobalNodeGroupListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<GlobalNodeGroup>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "GlobalNodeGroup" {
obj.push(GlobalNodeGroupDeserializer::deserialize(
"GlobalNodeGroup",
stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct GlobalReplicationGroup {
pub arn: Option<String>,
pub at_rest_encryption_enabled: Option<bool>,
pub auth_token_enabled: Option<bool>,
pub cache_node_type: Option<String>,
pub cluster_enabled: Option<bool>,
pub engine: Option<String>,
pub engine_version: Option<String>,
pub global_node_groups: Option<Vec<GlobalNodeGroup>>,
pub global_replication_group_description: Option<String>,
pub global_replication_group_id: Option<String>,
pub members: Option<Vec<GlobalReplicationGroupMember>>,
pub status: Option<String>,
pub transit_encryption_enabled: Option<bool>,
}
#[allow(dead_code)]
struct GlobalReplicationGroupDeserializer;
impl GlobalReplicationGroupDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<GlobalReplicationGroup, XmlParseError> {
deserialize_elements::<_, GlobalReplicationGroup, _>(tag_name, stack, |name, stack, obj| {
match name {
"ARN" => {
obj.arn = Some(StringDeserializer::deserialize("ARN", stack)?);
}
"AtRestEncryptionEnabled" => {
obj.at_rest_encryption_enabled = Some(
BooleanOptionalDeserializer::deserialize("AtRestEncryptionEnabled", stack)?,
);
}
"AuthTokenEnabled" => {
obj.auth_token_enabled = Some(BooleanOptionalDeserializer::deserialize(
"AuthTokenEnabled",
stack,
)?);
}
"CacheNodeType" => {
obj.cache_node_type =
Some(StringDeserializer::deserialize("CacheNodeType", stack)?);
}
"ClusterEnabled" => {
obj.cluster_enabled = Some(BooleanOptionalDeserializer::deserialize(
"ClusterEnabled",
stack,
)?);
}
"Engine" => {
obj.engine = Some(StringDeserializer::deserialize("Engine", stack)?);
}
"EngineVersion" => {
obj.engine_version =
Some(StringDeserializer::deserialize("EngineVersion", stack)?);
}
"GlobalNodeGroups" => {
obj.global_node_groups.get_or_insert(vec![]).extend(
GlobalNodeGroupListDeserializer::deserialize("GlobalNodeGroups", stack)?,
);
}
"GlobalReplicationGroupDescription" => {
obj.global_replication_group_description =
Some(StringDeserializer::deserialize(
"GlobalReplicationGroupDescription",
stack,
)?);
}
"GlobalReplicationGroupId" => {
obj.global_replication_group_id = Some(StringDeserializer::deserialize(
"GlobalReplicationGroupId",
stack,
)?);
}
"Members" => {
obj.members.get_or_insert(vec![]).extend(
GlobalReplicationGroupMemberListDeserializer::deserialize(
"Members", stack,
)?,
);
}
"Status" => {
obj.status = Some(StringDeserializer::deserialize("Status", stack)?);
}
"TransitEncryptionEnabled" => {
obj.transit_encryption_enabled =
Some(BooleanOptionalDeserializer::deserialize(
"TransitEncryptionEnabled",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct GlobalReplicationGroupInfo {
pub global_replication_group_id: Option<String>,
pub global_replication_group_member_role: Option<String>,
}
#[allow(dead_code)]
struct GlobalReplicationGroupInfoDeserializer;
impl GlobalReplicationGroupInfoDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<GlobalReplicationGroupInfo, XmlParseError> {
deserialize_elements::<_, GlobalReplicationGroupInfo, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"GlobalReplicationGroupId" => {
obj.global_replication_group_id = Some(StringDeserializer::deserialize(
"GlobalReplicationGroupId",
stack,
)?);
}
"GlobalReplicationGroupMemberRole" => {
obj.global_replication_group_member_role =
Some(StringDeserializer::deserialize(
"GlobalReplicationGroupMemberRole",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[allow(dead_code)]
struct GlobalReplicationGroupListDeserializer;
impl GlobalReplicationGroupListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<GlobalReplicationGroup>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "GlobalReplicationGroup" {
obj.push(GlobalReplicationGroupDeserializer::deserialize(
"GlobalReplicationGroup",
stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct GlobalReplicationGroupMember {
pub automatic_failover: Option<String>,
pub replication_group_id: Option<String>,
pub replication_group_region: Option<String>,
pub role: Option<String>,
pub status: Option<String>,
}
#[allow(dead_code)]
struct GlobalReplicationGroupMemberDeserializer;
impl GlobalReplicationGroupMemberDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<GlobalReplicationGroupMember, XmlParseError> {
deserialize_elements::<_, GlobalReplicationGroupMember, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"AutomaticFailover" => {
obj.automatic_failover =
Some(AutomaticFailoverStatusDeserializer::deserialize(
"AutomaticFailover",
stack,
)?);
}
"ReplicationGroupId" => {
obj.replication_group_id = Some(StringDeserializer::deserialize(
"ReplicationGroupId",
stack,
)?);
}
"ReplicationGroupRegion" => {
obj.replication_group_region = Some(StringDeserializer::deserialize(
"ReplicationGroupRegion",
stack,
)?);
}
"Role" => {
obj.role = Some(StringDeserializer::deserialize("Role", stack)?);
}
"Status" => {
obj.status = Some(StringDeserializer::deserialize("Status", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[allow(dead_code)]
struct GlobalReplicationGroupMemberListDeserializer;
impl GlobalReplicationGroupMemberListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<GlobalReplicationGroupMember>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "GlobalReplicationGroupMember" {
obj.push(GlobalReplicationGroupMemberDeserializer::deserialize(
"GlobalReplicationGroupMember",
stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct IncreaseNodeGroupsInGlobalReplicationGroupMessage {
pub apply_immediately: bool,
pub global_replication_group_id: String,
pub node_group_count: i64,
pub regional_configurations: Option<Vec<RegionalConfiguration>>,
}
struct IncreaseNodeGroupsInGlobalReplicationGroupMessageSerializer;
impl IncreaseNodeGroupsInGlobalReplicationGroupMessageSerializer {
fn serialize(
params: &mut Params,
name: &str,
obj: &IncreaseNodeGroupsInGlobalReplicationGroupMessage,
) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "ApplyImmediately"),
&obj.apply_immediately,
);
params.put(
&format!("{}{}", prefix, "GlobalReplicationGroupId"),
&obj.global_replication_group_id,
);
params.put(
&format!("{}{}", prefix, "NodeGroupCount"),
&obj.node_group_count,
);
if let Some(ref field_value) = obj.regional_configurations {
RegionalConfigurationListSerializer::serialize(
params,
&format!("{}{}", prefix, "RegionalConfiguration"),
field_value,
);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct IncreaseNodeGroupsInGlobalReplicationGroupResult {
pub global_replication_group: Option<GlobalReplicationGroup>,
}
#[allow(dead_code)]
struct IncreaseNodeGroupsInGlobalReplicationGroupResultDeserializer;
impl IncreaseNodeGroupsInGlobalReplicationGroupResultDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<IncreaseNodeGroupsInGlobalReplicationGroupResult, XmlParseError> {
deserialize_elements::<_, IncreaseNodeGroupsInGlobalReplicationGroupResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"GlobalReplicationGroup" => {
obj.global_replication_group =
Some(GlobalReplicationGroupDeserializer::deserialize(
"GlobalReplicationGroup",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct IncreaseReplicaCountMessage {
pub apply_immediately: bool,
pub new_replica_count: Option<i64>,
pub replica_configuration: Option<Vec<ConfigureShard>>,
pub replication_group_id: String,
}
struct IncreaseReplicaCountMessageSerializer;
impl IncreaseReplicaCountMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &IncreaseReplicaCountMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "ApplyImmediately"),
&obj.apply_immediately,
);
if let Some(ref field_value) = obj.new_replica_count {
params.put(&format!("{}{}", prefix, "NewReplicaCount"), &field_value);
}
if let Some(ref field_value) = obj.replica_configuration {
ReplicaConfigurationListSerializer::serialize(
params,
&format!("{}{}", prefix, "ConfigureShard"),
field_value,
);
}
params.put(
&format!("{}{}", prefix, "ReplicationGroupId"),
&obj.replication_group_id,
);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct IncreaseReplicaCountResult {
pub replication_group: Option<ReplicationGroup>,
}
#[allow(dead_code)]
struct IncreaseReplicaCountResultDeserializer;
impl IncreaseReplicaCountResultDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<IncreaseReplicaCountResult, XmlParseError> {
deserialize_elements::<_, IncreaseReplicaCountResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"ReplicationGroup" => {
obj.replication_group = Some(ReplicationGroupDeserializer::deserialize(
"ReplicationGroup",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[allow(dead_code)]
struct IntegerDeserializer;
impl IntegerDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<i64, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, |s| Ok(i64::from_str(&s).unwrap()))
}
}
#[allow(dead_code)]
struct IntegerOptionalDeserializer;
impl IntegerOptionalDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<i64, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, |s| Ok(i64::from_str(&s).unwrap()))
}
}
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(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListAllowedNodeTypeModificationsMessage {
pub cache_cluster_id: Option<String>,
pub replication_group_id: Option<String>,
}
struct ListAllowedNodeTypeModificationsMessageSerializer;
impl ListAllowedNodeTypeModificationsMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ListAllowedNodeTypeModificationsMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.cache_cluster_id {
params.put(&format!("{}{}", prefix, "CacheClusterId"), &field_value);
}
if let Some(ref field_value) = obj.replication_group_id {
params.put(&format!("{}{}", prefix, "ReplicationGroupId"), &field_value);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListTagsForResourceMessage {
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(".");
}
params.put(&format!("{}{}", prefix, "ResourceName"), &obj.resource_name);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ModifyCacheClusterMessage {
pub az_mode: Option<String>,
pub apply_immediately: Option<bool>,
pub auth_token: Option<String>,
pub auth_token_update_strategy: Option<String>,
pub auto_minor_version_upgrade: Option<bool>,
pub cache_cluster_id: String,
pub cache_node_ids_to_remove: Option<Vec<String>>,
pub cache_node_type: Option<String>,
pub cache_parameter_group_name: Option<String>,
pub cache_security_group_names: Option<Vec<String>>,
pub engine_version: Option<String>,
pub new_availability_zones: Option<Vec<String>>,
pub notification_topic_arn: Option<String>,
pub notification_topic_status: Option<String>,
pub num_cache_nodes: Option<i64>,
pub preferred_maintenance_window: Option<String>,
pub security_group_ids: Option<Vec<String>>,
pub snapshot_retention_limit: Option<i64>,
pub snapshot_window: Option<String>,
}
struct ModifyCacheClusterMessageSerializer;
impl ModifyCacheClusterMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ModifyCacheClusterMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.az_mode {
params.put(&format!("{}{}", prefix, "AZMode"), &field_value);
}
if let Some(ref field_value) = obj.apply_immediately {
params.put(&format!("{}{}", prefix, "ApplyImmediately"), &field_value);
}
if let Some(ref field_value) = obj.auth_token {
params.put(&format!("{}{}", prefix, "AuthToken"), &field_value);
}
if let Some(ref field_value) = obj.auth_token_update_strategy {
params.put(
&format!("{}{}", prefix, "AuthTokenUpdateStrategy"),
&field_value,
);
}
if let Some(ref field_value) = obj.auto_minor_version_upgrade {
params.put(
&format!("{}{}", prefix, "AutoMinorVersionUpgrade"),
&field_value,
);
}
params.put(
&format!("{}{}", prefix, "CacheClusterId"),
&obj.cache_cluster_id,
);
if let Some(ref field_value) = obj.cache_node_ids_to_remove {
CacheNodeIdsListSerializer::serialize(
params,
&format!("{}{}", prefix, "CacheNodeId"),
field_value,
);
}
if let Some(ref field_value) = obj.cache_node_type {
params.put(&format!("{}{}", prefix, "CacheNodeType"), &field_value);
}
if let Some(ref field_value) = obj.cache_parameter_group_name {
params.put(
&format!("{}{}", prefix, "CacheParameterGroupName"),
&field_value,
);
}
if let Some(ref field_value) = obj.cache_security_group_names {
CacheSecurityGroupNameListSerializer::serialize(
params,
&format!("{}{}", prefix, "CacheSecurityGroupName"),
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.new_availability_zones {
PreferredAvailabilityZoneListSerializer::serialize(
params,
&format!("{}{}", prefix, "PreferredAvailabilityZone"),
field_value,
);
}
if let Some(ref field_value) = obj.notification_topic_arn {
params.put(
&format!("{}{}", prefix, "NotificationTopicArn"),
&field_value,
);
}
if let Some(ref field_value) = obj.notification_topic_status {
params.put(
&format!("{}{}", prefix, "NotificationTopicStatus"),
&field_value,
);
}
if let Some(ref field_value) = obj.num_cache_nodes {
params.put(&format!("{}{}", prefix, "NumCacheNodes"), &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.security_group_ids {
SecurityGroupIdsListSerializer::serialize(
params,
&format!("{}{}", prefix, "SecurityGroupId"),
field_value,
);
}
if let Some(ref field_value) = obj.snapshot_retention_limit {
params.put(
&format!("{}{}", prefix, "SnapshotRetentionLimit"),
&field_value,
);
}
if let Some(ref field_value) = obj.snapshot_window {
params.put(&format!("{}{}", prefix, "SnapshotWindow"), &field_value);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct ModifyCacheClusterResult {
pub cache_cluster: Option<CacheCluster>,
}
#[allow(dead_code)]
struct ModifyCacheClusterResultDeserializer;
impl ModifyCacheClusterResultDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ModifyCacheClusterResult, XmlParseError> {
deserialize_elements::<_, ModifyCacheClusterResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"CacheCluster" => {
obj.cache_cluster = Some(CacheClusterDeserializer::deserialize(
"CacheCluster",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ModifyCacheParameterGroupMessage {
pub cache_parameter_group_name: String,
pub parameter_name_values: Vec<ParameterNameValue>,
}
struct ModifyCacheParameterGroupMessageSerializer;
impl ModifyCacheParameterGroupMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ModifyCacheParameterGroupMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "CacheParameterGroupName"),
&obj.cache_parameter_group_name,
);
ParameterNameValueListSerializer::serialize(
params,
&format!("{}{}", prefix, "ParameterNameValue"),
&obj.parameter_name_values,
);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ModifyCacheSubnetGroupMessage {
pub cache_subnet_group_description: Option<String>,
pub cache_subnet_group_name: String,
pub subnet_ids: Option<Vec<String>>,
}
struct ModifyCacheSubnetGroupMessageSerializer;
impl ModifyCacheSubnetGroupMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ModifyCacheSubnetGroupMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.cache_subnet_group_description {
params.put(
&format!("{}{}", prefix, "CacheSubnetGroupDescription"),
&field_value,
);
}
params.put(
&format!("{}{}", prefix, "CacheSubnetGroupName"),
&obj.cache_subnet_group_name,
);
if let Some(ref field_value) = obj.subnet_ids {
SubnetIdentifierListSerializer::serialize(
params,
&format!("{}{}", prefix, "SubnetIdentifier"),
field_value,
);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct ModifyCacheSubnetGroupResult {
pub cache_subnet_group: Option<CacheSubnetGroup>,
}
#[allow(dead_code)]
struct ModifyCacheSubnetGroupResultDeserializer;
impl ModifyCacheSubnetGroupResultDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ModifyCacheSubnetGroupResult, XmlParseError> {
deserialize_elements::<_, ModifyCacheSubnetGroupResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"CacheSubnetGroup" => {
obj.cache_subnet_group = Some(CacheSubnetGroupDeserializer::deserialize(
"CacheSubnetGroup",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ModifyGlobalReplicationGroupMessage {
pub apply_immediately: bool,
pub automatic_failover_enabled: Option<bool>,
pub cache_node_type: Option<String>,
pub engine_version: Option<String>,
pub global_replication_group_description: Option<String>,
pub global_replication_group_id: String,
}
struct ModifyGlobalReplicationGroupMessageSerializer;
impl ModifyGlobalReplicationGroupMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ModifyGlobalReplicationGroupMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "ApplyImmediately"),
&obj.apply_immediately,
);
if let Some(ref field_value) = obj.automatic_failover_enabled {
params.put(
&format!("{}{}", prefix, "AutomaticFailoverEnabled"),
&field_value,
);
}
if let Some(ref field_value) = obj.cache_node_type {
params.put(&format!("{}{}", prefix, "CacheNodeType"), &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.global_replication_group_description {
params.put(
&format!("{}{}", prefix, "GlobalReplicationGroupDescription"),
&field_value,
);
}
params.put(
&format!("{}{}", prefix, "GlobalReplicationGroupId"),
&obj.global_replication_group_id,
);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct ModifyGlobalReplicationGroupResult {
pub global_replication_group: Option<GlobalReplicationGroup>,
}
#[allow(dead_code)]
struct ModifyGlobalReplicationGroupResultDeserializer;
impl ModifyGlobalReplicationGroupResultDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ModifyGlobalReplicationGroupResult, XmlParseError> {
deserialize_elements::<_, ModifyGlobalReplicationGroupResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"GlobalReplicationGroup" => {
obj.global_replication_group =
Some(GlobalReplicationGroupDeserializer::deserialize(
"GlobalReplicationGroup",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ModifyReplicationGroupMessage {
pub apply_immediately: Option<bool>,
pub auth_token: Option<String>,
pub auth_token_update_strategy: Option<String>,
pub auto_minor_version_upgrade: Option<bool>,
pub automatic_failover_enabled: Option<bool>,
pub cache_node_type: Option<String>,
pub cache_parameter_group_name: Option<String>,
pub cache_security_group_names: Option<Vec<String>>,
pub engine_version: Option<String>,
pub multi_az_enabled: Option<bool>,
pub notification_topic_arn: Option<String>,
pub notification_topic_status: Option<String>,
pub preferred_maintenance_window: Option<String>,
pub primary_cluster_id: Option<String>,
pub replication_group_description: Option<String>,
pub replication_group_id: String,
pub security_group_ids: Option<Vec<String>>,
pub snapshot_retention_limit: Option<i64>,
pub snapshot_window: Option<String>,
pub snapshotting_cluster_id: Option<String>,
}
struct ModifyReplicationGroupMessageSerializer;
impl ModifyReplicationGroupMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ModifyReplicationGroupMessage) {
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);
}
if let Some(ref field_value) = obj.auth_token {
params.put(&format!("{}{}", prefix, "AuthToken"), &field_value);
}
if let Some(ref field_value) = obj.auth_token_update_strategy {
params.put(
&format!("{}{}", prefix, "AuthTokenUpdateStrategy"),
&field_value,
);
}
if let Some(ref field_value) = obj.auto_minor_version_upgrade {
params.put(
&format!("{}{}", prefix, "AutoMinorVersionUpgrade"),
&field_value,
);
}
if let Some(ref field_value) = obj.automatic_failover_enabled {
params.put(
&format!("{}{}", prefix, "AutomaticFailoverEnabled"),
&field_value,
);
}
if let Some(ref field_value) = obj.cache_node_type {
params.put(&format!("{}{}", prefix, "CacheNodeType"), &field_value);
}
if let Some(ref field_value) = obj.cache_parameter_group_name {
params.put(
&format!("{}{}", prefix, "CacheParameterGroupName"),
&field_value,
);
}
if let Some(ref field_value) = obj.cache_security_group_names {
CacheSecurityGroupNameListSerializer::serialize(
params,
&format!("{}{}", prefix, "CacheSecurityGroupName"),
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.multi_az_enabled {
params.put(&format!("{}{}", prefix, "MultiAZEnabled"), &field_value);
}
if let Some(ref field_value) = obj.notification_topic_arn {
params.put(
&format!("{}{}", prefix, "NotificationTopicArn"),
&field_value,
);
}
if let Some(ref field_value) = obj.notification_topic_status {
params.put(
&format!("{}{}", prefix, "NotificationTopicStatus"),
&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.primary_cluster_id {
params.put(&format!("{}{}", prefix, "PrimaryClusterId"), &field_value);
}
if let Some(ref field_value) = obj.replication_group_description {
params.put(
&format!("{}{}", prefix, "ReplicationGroupDescription"),
&field_value,
);
}
params.put(
&format!("{}{}", prefix, "ReplicationGroupId"),
&obj.replication_group_id,
);
if let Some(ref field_value) = obj.security_group_ids {
SecurityGroupIdsListSerializer::serialize(
params,
&format!("{}{}", prefix, "SecurityGroupId"),
field_value,
);
}
if let Some(ref field_value) = obj.snapshot_retention_limit {
params.put(
&format!("{}{}", prefix, "SnapshotRetentionLimit"),
&field_value,
);
}
if let Some(ref field_value) = obj.snapshot_window {
params.put(&format!("{}{}", prefix, "SnapshotWindow"), &field_value);
}
if let Some(ref field_value) = obj.snapshotting_cluster_id {
params.put(
&format!("{}{}", prefix, "SnapshottingClusterId"),
&field_value,
);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct ModifyReplicationGroupResult {
pub replication_group: Option<ReplicationGroup>,
}
#[allow(dead_code)]
struct ModifyReplicationGroupResultDeserializer;
impl ModifyReplicationGroupResultDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ModifyReplicationGroupResult, XmlParseError> {
deserialize_elements::<_, ModifyReplicationGroupResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"ReplicationGroup" => {
obj.replication_group = Some(ReplicationGroupDeserializer::deserialize(
"ReplicationGroup",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ModifyReplicationGroupShardConfigurationMessage {
pub apply_immediately: bool,
pub node_group_count: i64,
pub node_groups_to_remove: Option<Vec<String>>,
pub node_groups_to_retain: Option<Vec<String>>,
pub replication_group_id: String,
pub resharding_configuration: Option<Vec<ReshardingConfiguration>>,
}
struct ModifyReplicationGroupShardConfigurationMessageSerializer;
impl ModifyReplicationGroupShardConfigurationMessageSerializer {
fn serialize(
params: &mut Params,
name: &str,
obj: &ModifyReplicationGroupShardConfigurationMessage,
) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "ApplyImmediately"),
&obj.apply_immediately,
);
params.put(
&format!("{}{}", prefix, "NodeGroupCount"),
&obj.node_group_count,
);
if let Some(ref field_value) = obj.node_groups_to_remove {
NodeGroupsToRemoveListSerializer::serialize(
params,
&format!("{}{}", prefix, "NodeGroupToRemove"),
field_value,
);
}
if let Some(ref field_value) = obj.node_groups_to_retain {
NodeGroupsToRetainListSerializer::serialize(
params,
&format!("{}{}", prefix, "NodeGroupToRetain"),
field_value,
);
}
params.put(
&format!("{}{}", prefix, "ReplicationGroupId"),
&obj.replication_group_id,
);
if let Some(ref field_value) = obj.resharding_configuration {
ReshardingConfigurationListSerializer::serialize(
params,
&format!("{}{}", prefix, "ReshardingConfiguration"),
field_value,
);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct ModifyReplicationGroupShardConfigurationResult {
pub replication_group: Option<ReplicationGroup>,
}
#[allow(dead_code)]
struct ModifyReplicationGroupShardConfigurationResultDeserializer;
impl ModifyReplicationGroupShardConfigurationResultDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ModifyReplicationGroupShardConfigurationResult, XmlParseError> {
deserialize_elements::<_, ModifyReplicationGroupShardConfigurationResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"ReplicationGroup" => {
obj.replication_group = Some(ReplicationGroupDeserializer::deserialize(
"ReplicationGroup",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[allow(dead_code)]
struct MultiAZStatusDeserializer;
impl MultiAZStatusDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct NodeGroup {
pub node_group_id: Option<String>,
pub node_group_members: Option<Vec<NodeGroupMember>>,
pub primary_endpoint: Option<Endpoint>,
pub reader_endpoint: Option<Endpoint>,
pub slots: Option<String>,
pub status: Option<String>,
}
#[allow(dead_code)]
struct NodeGroupDeserializer;
impl NodeGroupDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<NodeGroup, XmlParseError> {
deserialize_elements::<_, NodeGroup, _>(tag_name, stack, |name, stack, obj| {
match name {
"NodeGroupId" => {
obj.node_group_id =
Some(StringDeserializer::deserialize("NodeGroupId", stack)?);
}
"NodeGroupMembers" => {
obj.node_group_members.get_or_insert(vec![]).extend(
NodeGroupMemberListDeserializer::deserialize("NodeGroupMembers", stack)?,
);
}
"PrimaryEndpoint" => {
obj.primary_endpoint =
Some(EndpointDeserializer::deserialize("PrimaryEndpoint", stack)?);
}
"ReaderEndpoint" => {
obj.reader_endpoint =
Some(EndpointDeserializer::deserialize("ReaderEndpoint", stack)?);
}
"Slots" => {
obj.slots = Some(StringDeserializer::deserialize("Slots", stack)?);
}
"Status" => {
obj.status = Some(StringDeserializer::deserialize("Status", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct NodeGroupConfiguration {
pub node_group_id: Option<String>,
pub primary_availability_zone: Option<String>,
pub replica_availability_zones: Option<Vec<String>>,
pub replica_count: Option<i64>,
pub slots: Option<String>,
}
#[allow(dead_code)]
struct NodeGroupConfigurationDeserializer;
impl NodeGroupConfigurationDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<NodeGroupConfiguration, XmlParseError> {
deserialize_elements::<_, NodeGroupConfiguration, _>(tag_name, stack, |name, stack, obj| {
match name {
"NodeGroupId" => {
obj.node_group_id = Some(AllowedNodeGroupIdDeserializer::deserialize(
"NodeGroupId",
stack,
)?);
}
"PrimaryAvailabilityZone" => {
obj.primary_availability_zone = Some(StringDeserializer::deserialize(
"PrimaryAvailabilityZone",
stack,
)?);
}
"ReplicaAvailabilityZones" => {
obj.replica_availability_zones.get_or_insert(vec![]).extend(
AvailabilityZonesListDeserializer::deserialize(
"ReplicaAvailabilityZones",
stack,
)?,
);
}
"ReplicaCount" => {
obj.replica_count = Some(IntegerOptionalDeserializer::deserialize(
"ReplicaCount",
stack,
)?);
}
"Slots" => {
obj.slots = Some(StringDeserializer::deserialize("Slots", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct NodeGroupConfigurationSerializer;
impl NodeGroupConfigurationSerializer {
fn serialize(params: &mut Params, name: &str, obj: &NodeGroupConfiguration) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.node_group_id {
params.put(&format!("{}{}", prefix, "NodeGroupId"), &field_value);
}
if let Some(ref field_value) = obj.primary_availability_zone {
params.put(
&format!("{}{}", prefix, "PrimaryAvailabilityZone"),
&field_value,
);
}
if let Some(ref field_value) = obj.replica_availability_zones {
AvailabilityZonesListSerializer::serialize(
params,
&format!("{}{}", prefix, "AvailabilityZone"),
field_value,
);
}
if let Some(ref field_value) = obj.replica_count {
params.put(&format!("{}{}", prefix, "ReplicaCount"), &field_value);
}
if let Some(ref field_value) = obj.slots {
params.put(&format!("{}{}", prefix, "Slots"), &field_value);
}
}
}
struct NodeGroupConfigurationListSerializer;
impl NodeGroupConfigurationListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<NodeGroupConfiguration>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.member.{}", name, index + 1);
NodeGroupConfigurationSerializer::serialize(params, &key, obj);
}
}
}
#[allow(dead_code)]
struct NodeGroupListDeserializer;
impl NodeGroupListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<NodeGroup>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "NodeGroup" {
obj.push(NodeGroupDeserializer::deserialize("NodeGroup", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct NodeGroupMember {
pub cache_cluster_id: Option<String>,
pub cache_node_id: Option<String>,
pub current_role: Option<String>,
pub preferred_availability_zone: Option<String>,
pub read_endpoint: Option<Endpoint>,
}
#[allow(dead_code)]
struct NodeGroupMemberDeserializer;
impl NodeGroupMemberDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<NodeGroupMember, XmlParseError> {
deserialize_elements::<_, NodeGroupMember, _>(tag_name, stack, |name, stack, obj| {
match name {
"CacheClusterId" => {
obj.cache_cluster_id =
Some(StringDeserializer::deserialize("CacheClusterId", stack)?);
}
"CacheNodeId" => {
obj.cache_node_id =
Some(StringDeserializer::deserialize("CacheNodeId", stack)?);
}
"CurrentRole" => {
obj.current_role = Some(StringDeserializer::deserialize("CurrentRole", stack)?);
}
"PreferredAvailabilityZone" => {
obj.preferred_availability_zone = Some(StringDeserializer::deserialize(
"PreferredAvailabilityZone",
stack,
)?);
}
"ReadEndpoint" => {
obj.read_endpoint =
Some(EndpointDeserializer::deserialize("ReadEndpoint", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[allow(dead_code)]
struct NodeGroupMemberListDeserializer;
impl NodeGroupMemberListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<NodeGroupMember>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "NodeGroupMember" {
obj.push(NodeGroupMemberDeserializer::deserialize(
"NodeGroupMember",
stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct NodeGroupMemberUpdateStatus {
pub cache_cluster_id: Option<String>,
pub cache_node_id: Option<String>,
pub node_deletion_date: Option<String>,
pub node_update_end_date: Option<String>,
pub node_update_initiated_by: Option<String>,
pub node_update_initiated_date: Option<String>,
pub node_update_start_date: Option<String>,
pub node_update_status: Option<String>,
pub node_update_status_modified_date: Option<String>,
}
#[allow(dead_code)]
struct NodeGroupMemberUpdateStatusDeserializer;
impl NodeGroupMemberUpdateStatusDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<NodeGroupMemberUpdateStatus, XmlParseError> {
deserialize_elements::<_, NodeGroupMemberUpdateStatus, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"CacheClusterId" => {
obj.cache_cluster_id =
Some(StringDeserializer::deserialize("CacheClusterId", stack)?);
}
"CacheNodeId" => {
obj.cache_node_id =
Some(StringDeserializer::deserialize("CacheNodeId", stack)?);
}
"NodeDeletionDate" => {
obj.node_deletion_date =
Some(TStampDeserializer::deserialize("NodeDeletionDate", stack)?);
}
"NodeUpdateEndDate" => {
obj.node_update_end_date =
Some(TStampDeserializer::deserialize("NodeUpdateEndDate", stack)?);
}
"NodeUpdateInitiatedBy" => {
obj.node_update_initiated_by =
Some(NodeUpdateInitiatedByDeserializer::deserialize(
"NodeUpdateInitiatedBy",
stack,
)?);
}
"NodeUpdateInitiatedDate" => {
obj.node_update_initiated_date = Some(TStampDeserializer::deserialize(
"NodeUpdateInitiatedDate",
stack,
)?);
}
"NodeUpdateStartDate" => {
obj.node_update_start_date = Some(TStampDeserializer::deserialize(
"NodeUpdateStartDate",
stack,
)?);
}
"NodeUpdateStatus" => {
obj.node_update_status = Some(NodeUpdateStatusDeserializer::deserialize(
"NodeUpdateStatus",
stack,
)?);
}
"NodeUpdateStatusModifiedDate" => {
obj.node_update_status_modified_date = Some(
TStampDeserializer::deserialize("NodeUpdateStatusModifiedDate", stack)?,
);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[allow(dead_code)]
struct NodeGroupMemberUpdateStatusListDeserializer;
impl NodeGroupMemberUpdateStatusListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<NodeGroupMemberUpdateStatus>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "NodeGroupMemberUpdateStatus" {
obj.push(NodeGroupMemberUpdateStatusDeserializer::deserialize(
"NodeGroupMemberUpdateStatus",
stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct NodeGroupUpdateStatus {
pub node_group_id: Option<String>,
pub node_group_member_update_status: Option<Vec<NodeGroupMemberUpdateStatus>>,
}
#[allow(dead_code)]
struct NodeGroupUpdateStatusDeserializer;
impl NodeGroupUpdateStatusDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<NodeGroupUpdateStatus, XmlParseError> {
deserialize_elements::<_, NodeGroupUpdateStatus, _>(tag_name, stack, |name, stack, obj| {
match name {
"NodeGroupId" => {
obj.node_group_id =
Some(StringDeserializer::deserialize("NodeGroupId", stack)?);
}
"NodeGroupMemberUpdateStatus" => {
obj.node_group_member_update_status
.get_or_insert(vec![])
.extend(NodeGroupMemberUpdateStatusListDeserializer::deserialize(
"NodeGroupMemberUpdateStatus",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[allow(dead_code)]
struct NodeGroupUpdateStatusListDeserializer;
impl NodeGroupUpdateStatusListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<NodeGroupUpdateStatus>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "NodeGroupUpdateStatus" {
obj.push(NodeGroupUpdateStatusDeserializer::deserialize(
"NodeGroupUpdateStatus",
stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct NodeGroupsToRemoveListSerializer;
impl NodeGroupsToRemoveListSerializer {
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 NodeGroupsToRetainListSerializer;
impl NodeGroupsToRetainListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.member.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct NodeSnapshot {
pub cache_cluster_id: Option<String>,
pub cache_node_create_time: Option<String>,
pub cache_node_id: Option<String>,
pub cache_size: Option<String>,
pub node_group_configuration: Option<NodeGroupConfiguration>,
pub node_group_id: Option<String>,
pub snapshot_create_time: Option<String>,
}
#[allow(dead_code)]
struct NodeSnapshotDeserializer;
impl NodeSnapshotDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<NodeSnapshot, XmlParseError> {
deserialize_elements::<_, NodeSnapshot, _>(tag_name, stack, |name, stack, obj| {
match name {
"CacheClusterId" => {
obj.cache_cluster_id =
Some(StringDeserializer::deserialize("CacheClusterId", stack)?);
}
"CacheNodeCreateTime" => {
obj.cache_node_create_time = Some(TStampDeserializer::deserialize(
"CacheNodeCreateTime",
stack,
)?);
}
"CacheNodeId" => {
obj.cache_node_id =
Some(StringDeserializer::deserialize("CacheNodeId", stack)?);
}
"CacheSize" => {
obj.cache_size = Some(StringDeserializer::deserialize("CacheSize", stack)?);
}
"NodeGroupConfiguration" => {
obj.node_group_configuration =
Some(NodeGroupConfigurationDeserializer::deserialize(
"NodeGroupConfiguration",
stack,
)?);
}
"NodeGroupId" => {
obj.node_group_id =
Some(StringDeserializer::deserialize("NodeGroupId", stack)?);
}
"SnapshotCreateTime" => {
obj.snapshot_create_time = Some(TStampDeserializer::deserialize(
"SnapshotCreateTime",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[allow(dead_code)]
struct NodeSnapshotListDeserializer;
impl NodeSnapshotListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<NodeSnapshot>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "NodeSnapshot" {
obj.push(NodeSnapshotDeserializer::deserialize(
"NodeSnapshot",
stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[allow(dead_code)]
struct NodeTypeListDeserializer;
impl NodeTypeListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<String>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "member" {
obj.push(StringDeserializer::deserialize("member", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[allow(dead_code)]
struct NodeUpdateInitiatedByDeserializer;
impl NodeUpdateInitiatedByDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct NodeUpdateStatusDeserializer;
impl NodeUpdateStatusDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct NotificationConfiguration {
pub topic_arn: Option<String>,
pub topic_status: Option<String>,
}
#[allow(dead_code)]
struct NotificationConfigurationDeserializer;
impl NotificationConfigurationDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<NotificationConfiguration, XmlParseError> {
deserialize_elements::<_, NotificationConfiguration, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"TopicArn" => {
obj.topic_arn = Some(StringDeserializer::deserialize("TopicArn", stack)?);
}
"TopicStatus" => {
obj.topic_status =
Some(StringDeserializer::deserialize("TopicStatus", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct Parameter {
pub allowed_values: Option<String>,
pub change_type: Option<String>,
pub data_type: Option<String>,
pub description: Option<String>,
pub is_modifiable: Option<bool>,
pub minimum_engine_version: Option<String>,
pub parameter_name: Option<String>,
pub parameter_value: Option<String>,
pub source: Option<String>,
}
#[allow(dead_code)]
struct ParameterDeserializer;
impl ParameterDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Parameter, XmlParseError> {
deserialize_elements::<_, Parameter, _>(tag_name, stack, |name, stack, obj| {
match name {
"AllowedValues" => {
obj.allowed_values =
Some(StringDeserializer::deserialize("AllowedValues", stack)?);
}
"ChangeType" => {
obj.change_type =
Some(ChangeTypeDeserializer::deserialize("ChangeType", stack)?);
}
"DataType" => {
obj.data_type = Some(StringDeserializer::deserialize("DataType", stack)?);
}
"Description" => {
obj.description = Some(StringDeserializer::deserialize("Description", stack)?);
}
"IsModifiable" => {
obj.is_modifiable =
Some(BooleanDeserializer::deserialize("IsModifiable", stack)?);
}
"MinimumEngineVersion" => {
obj.minimum_engine_version = Some(StringDeserializer::deserialize(
"MinimumEngineVersion",
stack,
)?);
}
"ParameterName" => {
obj.parameter_name =
Some(StringDeserializer::deserialize("ParameterName", stack)?);
}
"ParameterValue" => {
obj.parameter_value =
Some(StringDeserializer::deserialize("ParameterValue", stack)?);
}
"Source" => {
obj.source = Some(StringDeserializer::deserialize("Source", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ParameterNameValue {
pub parameter_name: Option<String>,
pub parameter_value: Option<String>,
}
struct ParameterNameValueSerializer;
impl ParameterNameValueSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ParameterNameValue) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
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);
}
}
}
struct ParameterNameValueListSerializer;
impl ParameterNameValueListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<ParameterNameValue>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.member.{}", name, index + 1);
ParameterNameValueSerializer::serialize(params, &key, obj);
}
}
}
#[allow(dead_code)]
struct ParametersListDeserializer;
impl ParametersListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<Parameter>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "Parameter" {
obj.push(ParameterDeserializer::deserialize("Parameter", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[allow(dead_code)]
struct PendingAutomaticFailoverStatusDeserializer;
impl PendingAutomaticFailoverStatusDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct PendingModifiedValues {
pub auth_token_status: Option<String>,
pub cache_node_ids_to_remove: Option<Vec<String>>,
pub cache_node_type: Option<String>,
pub engine_version: Option<String>,
pub num_cache_nodes: Option<i64>,
}
#[allow(dead_code)]
struct PendingModifiedValuesDeserializer;
impl PendingModifiedValuesDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<PendingModifiedValues, XmlParseError> {
deserialize_elements::<_, PendingModifiedValues, _>(tag_name, stack, |name, stack, obj| {
match name {
"AuthTokenStatus" => {
obj.auth_token_status = Some(AuthTokenUpdateStatusDeserializer::deserialize(
"AuthTokenStatus",
stack,
)?);
}
"CacheNodeIdsToRemove" => {
obj.cache_node_ids_to_remove.get_or_insert(vec![]).extend(
CacheNodeIdsListDeserializer::deserialize("CacheNodeIdsToRemove", stack)?,
);
}
"CacheNodeType" => {
obj.cache_node_type =
Some(StringDeserializer::deserialize("CacheNodeType", stack)?);
}
"EngineVersion" => {
obj.engine_version =
Some(StringDeserializer::deserialize("EngineVersion", stack)?);
}
"NumCacheNodes" => {
obj.num_cache_nodes = Some(IntegerOptionalDeserializer::deserialize(
"NumCacheNodes",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct PreferredAvailabilityZoneListSerializer;
impl PreferredAvailabilityZoneListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.member.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct ProcessedUpdateAction {
pub cache_cluster_id: Option<String>,
pub replication_group_id: Option<String>,
pub service_update_name: Option<String>,
pub update_action_status: Option<String>,
}
#[allow(dead_code)]
struct ProcessedUpdateActionDeserializer;
impl ProcessedUpdateActionDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ProcessedUpdateAction, XmlParseError> {
deserialize_elements::<_, ProcessedUpdateAction, _>(tag_name, stack, |name, stack, obj| {
match name {
"CacheClusterId" => {
obj.cache_cluster_id =
Some(StringDeserializer::deserialize("CacheClusterId", stack)?);
}
"ReplicationGroupId" => {
obj.replication_group_id = Some(StringDeserializer::deserialize(
"ReplicationGroupId",
stack,
)?);
}
"ServiceUpdateName" => {
obj.service_update_name =
Some(StringDeserializer::deserialize("ServiceUpdateName", stack)?);
}
"UpdateActionStatus" => {
obj.update_action_status = Some(UpdateActionStatusDeserializer::deserialize(
"UpdateActionStatus",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[allow(dead_code)]
struct ProcessedUpdateActionListDeserializer;
impl ProcessedUpdateActionListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<ProcessedUpdateAction>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "ProcessedUpdateAction" {
obj.push(ProcessedUpdateActionDeserializer::deserialize(
"ProcessedUpdateAction",
stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct PurchaseReservedCacheNodesOfferingMessage {
pub cache_node_count: Option<i64>,
pub reserved_cache_node_id: Option<String>,
pub reserved_cache_nodes_offering_id: String,
}
struct PurchaseReservedCacheNodesOfferingMessageSerializer;
impl PurchaseReservedCacheNodesOfferingMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &PurchaseReservedCacheNodesOfferingMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.cache_node_count {
params.put(&format!("{}{}", prefix, "CacheNodeCount"), &field_value);
}
if let Some(ref field_value) = obj.reserved_cache_node_id {
params.put(
&format!("{}{}", prefix, "ReservedCacheNodeId"),
&field_value,
);
}
params.put(
&format!("{}{}", prefix, "ReservedCacheNodesOfferingId"),
&obj.reserved_cache_nodes_offering_id,
);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct PurchaseReservedCacheNodesOfferingResult {
pub reserved_cache_node: Option<ReservedCacheNode>,
}
#[allow(dead_code)]
struct PurchaseReservedCacheNodesOfferingResultDeserializer;
impl PurchaseReservedCacheNodesOfferingResultDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<PurchaseReservedCacheNodesOfferingResult, XmlParseError> {
deserialize_elements::<_, PurchaseReservedCacheNodesOfferingResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"ReservedCacheNode" => {
obj.reserved_cache_node = Some(ReservedCacheNodeDeserializer::deserialize(
"ReservedCacheNode",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct RebalanceSlotsInGlobalReplicationGroupMessage {
pub apply_immediately: bool,
pub global_replication_group_id: String,
}
struct RebalanceSlotsInGlobalReplicationGroupMessageSerializer;
impl RebalanceSlotsInGlobalReplicationGroupMessageSerializer {
fn serialize(
params: &mut Params,
name: &str,
obj: &RebalanceSlotsInGlobalReplicationGroupMessage,
) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "ApplyImmediately"),
&obj.apply_immediately,
);
params.put(
&format!("{}{}", prefix, "GlobalReplicationGroupId"),
&obj.global_replication_group_id,
);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct RebalanceSlotsInGlobalReplicationGroupResult {
pub global_replication_group: Option<GlobalReplicationGroup>,
}
#[allow(dead_code)]
struct RebalanceSlotsInGlobalReplicationGroupResultDeserializer;
impl RebalanceSlotsInGlobalReplicationGroupResultDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<RebalanceSlotsInGlobalReplicationGroupResult, XmlParseError> {
deserialize_elements::<_, RebalanceSlotsInGlobalReplicationGroupResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"GlobalReplicationGroup" => {
obj.global_replication_group =
Some(GlobalReplicationGroupDeserializer::deserialize(
"GlobalReplicationGroup",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct RebootCacheClusterMessage {
pub cache_cluster_id: String,
pub cache_node_ids_to_reboot: Vec<String>,
}
struct RebootCacheClusterMessageSerializer;
impl RebootCacheClusterMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &RebootCacheClusterMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "CacheClusterId"),
&obj.cache_cluster_id,
);
CacheNodeIdsListSerializer::serialize(
params,
&format!("{}{}", prefix, "CacheNodeId"),
&obj.cache_node_ids_to_reboot,
);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct RebootCacheClusterResult {
pub cache_cluster: Option<CacheCluster>,
}
#[allow(dead_code)]
struct RebootCacheClusterResultDeserializer;
impl RebootCacheClusterResultDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<RebootCacheClusterResult, XmlParseError> {
deserialize_elements::<_, RebootCacheClusterResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"CacheCluster" => {
obj.cache_cluster = Some(CacheClusterDeserializer::deserialize(
"CacheCluster",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct RecurringCharge {
pub recurring_charge_amount: Option<f64>,
pub recurring_charge_frequency: Option<String>,
}
#[allow(dead_code)]
struct RecurringChargeDeserializer;
impl RecurringChargeDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<RecurringCharge, XmlParseError> {
deserialize_elements::<_, RecurringCharge, _>(tag_name, stack, |name, stack, obj| {
match name {
"RecurringChargeAmount" => {
obj.recurring_charge_amount = Some(DoubleDeserializer::deserialize(
"RecurringChargeAmount",
stack,
)?);
}
"RecurringChargeFrequency" => {
obj.recurring_charge_frequency = Some(StringDeserializer::deserialize(
"RecurringChargeFrequency",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[allow(dead_code)]
struct RecurringChargeListDeserializer;
impl RecurringChargeListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<RecurringCharge>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "RecurringCharge" {
obj.push(RecurringChargeDeserializer::deserialize(
"RecurringCharge",
stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct RegionalConfiguration {
pub replication_group_id: String,
pub replication_group_region: String,
pub resharding_configuration: Vec<ReshardingConfiguration>,
}
struct RegionalConfigurationSerializer;
impl RegionalConfigurationSerializer {
fn serialize(params: &mut Params, name: &str, obj: &RegionalConfiguration) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "ReplicationGroupId"),
&obj.replication_group_id,
);
params.put(
&format!("{}{}", prefix, "ReplicationGroupRegion"),
&obj.replication_group_region,
);
ReshardingConfigurationListSerializer::serialize(
params,
&format!("{}{}", prefix, "ReshardingConfiguration"),
&obj.resharding_configuration,
);
}
}
struct RegionalConfigurationListSerializer;
impl RegionalConfigurationListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<RegionalConfiguration>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.member.{}", name, index + 1);
RegionalConfigurationSerializer::serialize(params, &key, obj);
}
}
}
struct RemoveReplicasListSerializer;
impl RemoveReplicasListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.member.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
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);
}
}
struct ReplicaConfigurationListSerializer;
impl ReplicaConfigurationListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<ConfigureShard>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.member.{}", name, index + 1);
ConfigureShardSerializer::serialize(params, &key, obj);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct ReplicationGroup {
pub arn: Option<String>,
pub at_rest_encryption_enabled: Option<bool>,
pub auth_token_enabled: Option<bool>,
pub auth_token_last_modified_date: Option<String>,
pub automatic_failover: Option<String>,
pub cache_node_type: Option<String>,
pub cluster_enabled: Option<bool>,
pub configuration_endpoint: Option<Endpoint>,
pub description: Option<String>,
pub global_replication_group_info: Option<GlobalReplicationGroupInfo>,
pub kms_key_id: Option<String>,
pub member_clusters: Option<Vec<String>>,
pub multi_az: Option<String>,
pub node_groups: Option<Vec<NodeGroup>>,
pub pending_modified_values: Option<ReplicationGroupPendingModifiedValues>,
pub replication_group_id: Option<String>,
pub snapshot_retention_limit: Option<i64>,
pub snapshot_window: Option<String>,
pub snapshotting_cluster_id: Option<String>,
pub status: Option<String>,
pub transit_encryption_enabled: Option<bool>,
}
#[allow(dead_code)]
struct ReplicationGroupDeserializer;
impl ReplicationGroupDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ReplicationGroup, XmlParseError> {
deserialize_elements::<_, ReplicationGroup, _>(tag_name, stack, |name, stack, obj| {
match name {
"ARN" => {
obj.arn = Some(StringDeserializer::deserialize("ARN", stack)?);
}
"AtRestEncryptionEnabled" => {
obj.at_rest_encryption_enabled = Some(
BooleanOptionalDeserializer::deserialize("AtRestEncryptionEnabled", stack)?,
);
}
"AuthTokenEnabled" => {
obj.auth_token_enabled = Some(BooleanOptionalDeserializer::deserialize(
"AuthTokenEnabled",
stack,
)?);
}
"AuthTokenLastModifiedDate" => {
obj.auth_token_last_modified_date = Some(TStampDeserializer::deserialize(
"AuthTokenLastModifiedDate",
stack,
)?);
}
"AutomaticFailover" => {
obj.automatic_failover =
Some(AutomaticFailoverStatusDeserializer::deserialize(
"AutomaticFailover",
stack,
)?);
}
"CacheNodeType" => {
obj.cache_node_type =
Some(StringDeserializer::deserialize("CacheNodeType", stack)?);
}
"ClusterEnabled" => {
obj.cluster_enabled = Some(BooleanOptionalDeserializer::deserialize(
"ClusterEnabled",
stack,
)?);
}
"ConfigurationEndpoint" => {
obj.configuration_endpoint = Some(EndpointDeserializer::deserialize(
"ConfigurationEndpoint",
stack,
)?);
}
"Description" => {
obj.description = Some(StringDeserializer::deserialize("Description", stack)?);
}
"GlobalReplicationGroupInfo" => {
obj.global_replication_group_info =
Some(GlobalReplicationGroupInfoDeserializer::deserialize(
"GlobalReplicationGroupInfo",
stack,
)?);
}
"KmsKeyId" => {
obj.kms_key_id = Some(StringDeserializer::deserialize("KmsKeyId", stack)?);
}
"MemberClusters" => {
obj.member_clusters.get_or_insert(vec![]).extend(
ClusterIdListDeserializer::deserialize("MemberClusters", stack)?,
);
}
"MultiAZ" => {
obj.multi_az = Some(MultiAZStatusDeserializer::deserialize("MultiAZ", stack)?);
}
"NodeGroups" => {
obj.node_groups
.get_or_insert(vec![])
.extend(NodeGroupListDeserializer::deserialize("NodeGroups", stack)?);
}
"PendingModifiedValues" => {
obj.pending_modified_values = Some(
ReplicationGroupPendingModifiedValuesDeserializer::deserialize(
"PendingModifiedValues",
stack,
)?,
);
}
"ReplicationGroupId" => {
obj.replication_group_id = Some(StringDeserializer::deserialize(
"ReplicationGroupId",
stack,
)?);
}
"SnapshotRetentionLimit" => {
obj.snapshot_retention_limit = Some(IntegerOptionalDeserializer::deserialize(
"SnapshotRetentionLimit",
stack,
)?);
}
"SnapshotWindow" => {
obj.snapshot_window =
Some(StringDeserializer::deserialize("SnapshotWindow", stack)?);
}
"SnapshottingClusterId" => {
obj.snapshotting_cluster_id = Some(StringDeserializer::deserialize(
"SnapshottingClusterId",
stack,
)?);
}
"Status" => {
obj.status = Some(StringDeserializer::deserialize("Status", stack)?);
}
"TransitEncryptionEnabled" => {
obj.transit_encryption_enabled =
Some(BooleanOptionalDeserializer::deserialize(
"TransitEncryptionEnabled",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct ReplicationGroupIdListSerializer;
impl ReplicationGroupIdListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.member.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
#[allow(dead_code)]
struct ReplicationGroupListDeserializer;
impl ReplicationGroupListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<ReplicationGroup>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "ReplicationGroup" {
obj.push(ReplicationGroupDeserializer::deserialize(
"ReplicationGroup",
stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct ReplicationGroupMessage {
pub marker: Option<String>,
pub replication_groups: Option<Vec<ReplicationGroup>>,
}
#[allow(dead_code)]
struct ReplicationGroupMessageDeserializer;
impl ReplicationGroupMessageDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ReplicationGroupMessage, XmlParseError> {
deserialize_elements::<_, ReplicationGroupMessage, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"Marker" => {
obj.marker = Some(StringDeserializer::deserialize("Marker", stack)?);
}
"ReplicationGroups" => {
obj.replication_groups.get_or_insert(vec![]).extend(
ReplicationGroupListDeserializer::deserialize(
"ReplicationGroups",
stack,
)?,
);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct ReplicationGroupPendingModifiedValues {
pub auth_token_status: Option<String>,
pub automatic_failover_status: Option<String>,
pub primary_cluster_id: Option<String>,
pub resharding: Option<ReshardingStatus>,
}
#[allow(dead_code)]
struct ReplicationGroupPendingModifiedValuesDeserializer;
impl ReplicationGroupPendingModifiedValuesDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ReplicationGroupPendingModifiedValues, XmlParseError> {
deserialize_elements::<_, ReplicationGroupPendingModifiedValues, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"AuthTokenStatus" => {
obj.auth_token_status =
Some(AuthTokenUpdateStatusDeserializer::deserialize(
"AuthTokenStatus",
stack,
)?);
}
"AutomaticFailoverStatus" => {
obj.automatic_failover_status =
Some(PendingAutomaticFailoverStatusDeserializer::deserialize(
"AutomaticFailoverStatus",
stack,
)?);
}
"PrimaryClusterId" => {
obj.primary_cluster_id =
Some(StringDeserializer::deserialize("PrimaryClusterId", stack)?);
}
"Resharding" => {
obj.resharding = Some(ReshardingStatusDeserializer::deserialize(
"Resharding",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct ReservedCacheNode {
pub cache_node_count: Option<i64>,
pub cache_node_type: Option<String>,
pub duration: Option<i64>,
pub fixed_price: Option<f64>,
pub offering_type: Option<String>,
pub product_description: Option<String>,
pub recurring_charges: Option<Vec<RecurringCharge>>,
pub reservation_arn: Option<String>,
pub reserved_cache_node_id: Option<String>,
pub reserved_cache_nodes_offering_id: Option<String>,
pub start_time: Option<String>,
pub state: Option<String>,
pub usage_price: Option<f64>,
}
#[allow(dead_code)]
struct ReservedCacheNodeDeserializer;
impl ReservedCacheNodeDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ReservedCacheNode, XmlParseError> {
deserialize_elements::<_, ReservedCacheNode, _>(tag_name, stack, |name, stack, obj| {
match name {
"CacheNodeCount" => {
obj.cache_node_count =
Some(IntegerDeserializer::deserialize("CacheNodeCount", stack)?);
}
"CacheNodeType" => {
obj.cache_node_type =
Some(StringDeserializer::deserialize("CacheNodeType", stack)?);
}
"Duration" => {
obj.duration = Some(IntegerDeserializer::deserialize("Duration", stack)?);
}
"FixedPrice" => {
obj.fixed_price = Some(DoubleDeserializer::deserialize("FixedPrice", stack)?);
}
"OfferingType" => {
obj.offering_type =
Some(StringDeserializer::deserialize("OfferingType", stack)?);
}
"ProductDescription" => {
obj.product_description = Some(StringDeserializer::deserialize(
"ProductDescription",
stack,
)?);
}
"RecurringCharges" => {
obj.recurring_charges.get_or_insert(vec![]).extend(
RecurringChargeListDeserializer::deserialize("RecurringCharges", stack)?,
);
}
"ReservationARN" => {
obj.reservation_arn =
Some(StringDeserializer::deserialize("ReservationARN", stack)?);
}
"ReservedCacheNodeId" => {
obj.reserved_cache_node_id = Some(StringDeserializer::deserialize(
"ReservedCacheNodeId",
stack,
)?);
}
"ReservedCacheNodesOfferingId" => {
obj.reserved_cache_nodes_offering_id = Some(StringDeserializer::deserialize(
"ReservedCacheNodesOfferingId",
stack,
)?);
}
"StartTime" => {
obj.start_time = Some(TStampDeserializer::deserialize("StartTime", stack)?);
}
"State" => {
obj.state = Some(StringDeserializer::deserialize("State", stack)?);
}
"UsagePrice" => {
obj.usage_price = Some(DoubleDeserializer::deserialize("UsagePrice", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[allow(dead_code)]
struct ReservedCacheNodeListDeserializer;
impl ReservedCacheNodeListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<ReservedCacheNode>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "ReservedCacheNode" {
obj.push(ReservedCacheNodeDeserializer::deserialize(
"ReservedCacheNode",
stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct ReservedCacheNodeMessage {
pub marker: Option<String>,
pub reserved_cache_nodes: Option<Vec<ReservedCacheNode>>,
}
#[allow(dead_code)]
struct ReservedCacheNodeMessageDeserializer;
impl ReservedCacheNodeMessageDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ReservedCacheNodeMessage, XmlParseError> {
deserialize_elements::<_, ReservedCacheNodeMessage, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"Marker" => {
obj.marker = Some(StringDeserializer::deserialize("Marker", stack)?);
}
"ReservedCacheNodes" => {
obj.reserved_cache_nodes.get_or_insert(vec![]).extend(
ReservedCacheNodeListDeserializer::deserialize(
"ReservedCacheNodes",
stack,
)?,
);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct ReservedCacheNodesOffering {
pub cache_node_type: Option<String>,
pub duration: Option<i64>,
pub fixed_price: Option<f64>,
pub offering_type: Option<String>,
pub product_description: Option<String>,
pub recurring_charges: Option<Vec<RecurringCharge>>,
pub reserved_cache_nodes_offering_id: Option<String>,
pub usage_price: Option<f64>,
}
#[allow(dead_code)]
struct ReservedCacheNodesOfferingDeserializer;
impl ReservedCacheNodesOfferingDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ReservedCacheNodesOffering, XmlParseError> {
deserialize_elements::<_, ReservedCacheNodesOffering, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"CacheNodeType" => {
obj.cache_node_type =
Some(StringDeserializer::deserialize("CacheNodeType", stack)?);
}
"Duration" => {
obj.duration = Some(IntegerDeserializer::deserialize("Duration", stack)?);
}
"FixedPrice" => {
obj.fixed_price =
Some(DoubleDeserializer::deserialize("FixedPrice", stack)?);
}
"OfferingType" => {
obj.offering_type =
Some(StringDeserializer::deserialize("OfferingType", stack)?);
}
"ProductDescription" => {
obj.product_description = Some(StringDeserializer::deserialize(
"ProductDescription",
stack,
)?);
}
"RecurringCharges" => {
obj.recurring_charges.get_or_insert(vec![]).extend(
RecurringChargeListDeserializer::deserialize(
"RecurringCharges",
stack,
)?,
);
}
"ReservedCacheNodesOfferingId" => {
obj.reserved_cache_nodes_offering_id = Some(
StringDeserializer::deserialize("ReservedCacheNodesOfferingId", stack)?,
);
}
"UsagePrice" => {
obj.usage_price =
Some(DoubleDeserializer::deserialize("UsagePrice", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[allow(dead_code)]
struct ReservedCacheNodesOfferingListDeserializer;
impl ReservedCacheNodesOfferingListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<ReservedCacheNodesOffering>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "ReservedCacheNodesOffering" {
obj.push(ReservedCacheNodesOfferingDeserializer::deserialize(
"ReservedCacheNodesOffering",
stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct ReservedCacheNodesOfferingMessage {
pub marker: Option<String>,
pub reserved_cache_nodes_offerings: Option<Vec<ReservedCacheNodesOffering>>,
}
#[allow(dead_code)]
struct ReservedCacheNodesOfferingMessageDeserializer;
impl ReservedCacheNodesOfferingMessageDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ReservedCacheNodesOfferingMessage, XmlParseError> {
deserialize_elements::<_, ReservedCacheNodesOfferingMessage, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"Marker" => {
obj.marker = Some(StringDeserializer::deserialize("Marker", stack)?);
}
"ReservedCacheNodesOfferings" => {
obj.reserved_cache_nodes_offerings
.get_or_insert(vec![])
.extend(ReservedCacheNodesOfferingListDeserializer::deserialize(
"ReservedCacheNodesOfferings",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ResetCacheParameterGroupMessage {
pub cache_parameter_group_name: String,
pub parameter_name_values: Option<Vec<ParameterNameValue>>,
pub reset_all_parameters: Option<bool>,
}
struct ResetCacheParameterGroupMessageSerializer;
impl ResetCacheParameterGroupMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ResetCacheParameterGroupMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "CacheParameterGroupName"),
&obj.cache_parameter_group_name,
);
if let Some(ref field_value) = obj.parameter_name_values {
ParameterNameValueListSerializer::serialize(
params,
&format!("{}{}", prefix, "ParameterNameValue"),
field_value,
);
}
if let Some(ref field_value) = obj.reset_all_parameters {
params.put(&format!("{}{}", prefix, "ResetAllParameters"), &field_value);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ReshardingConfiguration {
pub node_group_id: Option<String>,
pub preferred_availability_zones: Option<Vec<String>>,
}
struct ReshardingConfigurationSerializer;
impl ReshardingConfigurationSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ReshardingConfiguration) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.node_group_id {
params.put(&format!("{}{}", prefix, "NodeGroupId"), &field_value);
}
if let Some(ref field_value) = obj.preferred_availability_zones {
AvailabilityZonesListSerializer::serialize(
params,
&format!("{}{}", prefix, "AvailabilityZone"),
field_value,
);
}
}
}
struct ReshardingConfigurationListSerializer;
impl ReshardingConfigurationListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<ReshardingConfiguration>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.member.{}", name, index + 1);
ReshardingConfigurationSerializer::serialize(params, &key, obj);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct ReshardingStatus {
pub slot_migration: Option<SlotMigration>,
}
#[allow(dead_code)]
struct ReshardingStatusDeserializer;
impl ReshardingStatusDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ReshardingStatus, XmlParseError> {
deserialize_elements::<_, ReshardingStatus, _>(tag_name, stack, |name, stack, obj| {
match name {
"SlotMigration" => {
obj.slot_migration = Some(SlotMigrationDeserializer::deserialize(
"SlotMigration",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct RevokeCacheSecurityGroupIngressMessage {
pub cache_security_group_name: String,
pub ec2_security_group_name: String,
pub ec2_security_group_owner_id: String,
}
struct RevokeCacheSecurityGroupIngressMessageSerializer;
impl RevokeCacheSecurityGroupIngressMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &RevokeCacheSecurityGroupIngressMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "CacheSecurityGroupName"),
&obj.cache_security_group_name,
);
params.put(
&format!("{}{}", prefix, "EC2SecurityGroupName"),
&obj.ec2_security_group_name,
);
params.put(
&format!("{}{}", prefix, "EC2SecurityGroupOwnerId"),
&obj.ec2_security_group_owner_id,
);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct RevokeCacheSecurityGroupIngressResult {
pub cache_security_group: Option<CacheSecurityGroup>,
}
#[allow(dead_code)]
struct RevokeCacheSecurityGroupIngressResultDeserializer;
impl RevokeCacheSecurityGroupIngressResultDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<RevokeCacheSecurityGroupIngressResult, XmlParseError> {
deserialize_elements::<_, RevokeCacheSecurityGroupIngressResult, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"CacheSecurityGroup" => {
obj.cache_security_group =
Some(CacheSecurityGroupDeserializer::deserialize(
"CacheSecurityGroup",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
struct SecurityGroupIdsListSerializer;
impl SecurityGroupIdsListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.member.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct SecurityGroupMembership {
pub security_group_id: Option<String>,
pub status: Option<String>,
}
#[allow(dead_code)]
struct SecurityGroupMembershipDeserializer;
impl SecurityGroupMembershipDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<SecurityGroupMembership, XmlParseError> {
deserialize_elements::<_, SecurityGroupMembership, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"SecurityGroupId" => {
obj.security_group_id =
Some(StringDeserializer::deserialize("SecurityGroupId", stack)?);
}
"Status" => {
obj.status = Some(StringDeserializer::deserialize("Status", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[allow(dead_code)]
struct SecurityGroupMembershipListDeserializer;
impl SecurityGroupMembershipListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<SecurityGroupMembership>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "member" {
obj.push(SecurityGroupMembershipDeserializer::deserialize(
"member", stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct ServiceUpdate {
pub auto_update_after_recommended_apply_by_date: Option<bool>,
pub engine: Option<String>,
pub engine_version: Option<String>,
pub estimated_update_time: Option<String>,
pub service_update_description: Option<String>,
pub service_update_end_date: Option<String>,
pub service_update_name: Option<String>,
pub service_update_recommended_apply_by_date: Option<String>,
pub service_update_release_date: Option<String>,
pub service_update_severity: Option<String>,
pub service_update_status: Option<String>,
pub service_update_type: Option<String>,
}
#[allow(dead_code)]
struct ServiceUpdateDeserializer;
impl ServiceUpdateDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ServiceUpdate, XmlParseError> {
deserialize_elements::<_, ServiceUpdate, _>(tag_name, stack, |name, stack, obj| {
match name {
"AutoUpdateAfterRecommendedApplyByDate" => {
obj.auto_update_after_recommended_apply_by_date =
Some(BooleanOptionalDeserializer::deserialize(
"AutoUpdateAfterRecommendedApplyByDate",
stack,
)?);
}
"Engine" => {
obj.engine = Some(StringDeserializer::deserialize("Engine", stack)?);
}
"EngineVersion" => {
obj.engine_version =
Some(StringDeserializer::deserialize("EngineVersion", stack)?);
}
"EstimatedUpdateTime" => {
obj.estimated_update_time = Some(StringDeserializer::deserialize(
"EstimatedUpdateTime",
stack,
)?);
}
"ServiceUpdateDescription" => {
obj.service_update_description = Some(StringDeserializer::deserialize(
"ServiceUpdateDescription",
stack,
)?);
}
"ServiceUpdateEndDate" => {
obj.service_update_end_date = Some(TStampDeserializer::deserialize(
"ServiceUpdateEndDate",
stack,
)?);
}
"ServiceUpdateName" => {
obj.service_update_name =
Some(StringDeserializer::deserialize("ServiceUpdateName", stack)?);
}
"ServiceUpdateRecommendedApplyByDate" => {
obj.service_update_recommended_apply_by_date =
Some(TStampDeserializer::deserialize(
"ServiceUpdateRecommendedApplyByDate",
stack,
)?);
}
"ServiceUpdateReleaseDate" => {
obj.service_update_release_date = Some(TStampDeserializer::deserialize(
"ServiceUpdateReleaseDate",
stack,
)?);
}
"ServiceUpdateSeverity" => {
obj.service_update_severity =
Some(ServiceUpdateSeverityDeserializer::deserialize(
"ServiceUpdateSeverity",
stack,
)?);
}
"ServiceUpdateStatus" => {
obj.service_update_status = Some(ServiceUpdateStatusDeserializer::deserialize(
"ServiceUpdateStatus",
stack,
)?);
}
"ServiceUpdateType" => {
obj.service_update_type = Some(ServiceUpdateTypeDeserializer::deserialize(
"ServiceUpdateType",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[allow(dead_code)]
struct ServiceUpdateListDeserializer;
impl ServiceUpdateListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<ServiceUpdate>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "ServiceUpdate" {
obj.push(ServiceUpdateDeserializer::deserialize(
"ServiceUpdate",
stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[allow(dead_code)]
struct ServiceUpdateSeverityDeserializer;
impl ServiceUpdateSeverityDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct ServiceUpdateStatusDeserializer;
impl ServiceUpdateStatusDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
struct ServiceUpdateStatusListSerializer;
impl ServiceUpdateStatusListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.member.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
#[allow(dead_code)]
struct ServiceUpdateTypeDeserializer;
impl ServiceUpdateTypeDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct ServiceUpdatesMessage {
pub marker: Option<String>,
pub service_updates: Option<Vec<ServiceUpdate>>,
}
#[allow(dead_code)]
struct ServiceUpdatesMessageDeserializer;
impl ServiceUpdatesMessageDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ServiceUpdatesMessage, XmlParseError> {
deserialize_elements::<_, ServiceUpdatesMessage, _>(tag_name, stack, |name, stack, obj| {
match name {
"Marker" => {
obj.marker = Some(StringDeserializer::deserialize("Marker", stack)?);
}
"ServiceUpdates" => {
obj.service_updates.get_or_insert(vec![]).extend(
ServiceUpdateListDeserializer::deserialize("ServiceUpdates", stack)?,
);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[allow(dead_code)]
struct SlaMetDeserializer;
impl SlaMetDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct SlotMigration {
pub progress_percentage: Option<f64>,
}
#[allow(dead_code)]
struct SlotMigrationDeserializer;
impl SlotMigrationDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<SlotMigration, XmlParseError> {
deserialize_elements::<_, SlotMigration, _>(tag_name, stack, |name, stack, obj| {
match name {
"ProgressPercentage" => {
obj.progress_percentage = Some(DoubleDeserializer::deserialize(
"ProgressPercentage",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct Snapshot {
pub arn: Option<String>,
pub auto_minor_version_upgrade: Option<bool>,
pub automatic_failover: Option<String>,
pub cache_cluster_create_time: Option<String>,
pub cache_cluster_id: Option<String>,
pub cache_node_type: Option<String>,
pub cache_parameter_group_name: Option<String>,
pub cache_subnet_group_name: Option<String>,
pub engine: Option<String>,
pub engine_version: Option<String>,
pub kms_key_id: Option<String>,
pub node_snapshots: Option<Vec<NodeSnapshot>>,
pub num_cache_nodes: Option<i64>,
pub num_node_groups: Option<i64>,
pub port: Option<i64>,
pub preferred_availability_zone: Option<String>,
pub preferred_maintenance_window: Option<String>,
pub replication_group_description: Option<String>,
pub replication_group_id: Option<String>,
pub snapshot_name: Option<String>,
pub snapshot_retention_limit: Option<i64>,
pub snapshot_source: Option<String>,
pub snapshot_status: Option<String>,
pub snapshot_window: Option<String>,
pub topic_arn: Option<String>,
pub vpc_id: Option<String>,
}
#[allow(dead_code)]
struct SnapshotDeserializer;
impl SnapshotDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Snapshot, XmlParseError> {
deserialize_elements::<_, Snapshot, _>(tag_name, stack, |name, stack, obj| {
match name {
"ARN" => {
obj.arn = Some(StringDeserializer::deserialize("ARN", stack)?);
}
"AutoMinorVersionUpgrade" => {
obj.auto_minor_version_upgrade = Some(BooleanDeserializer::deserialize(
"AutoMinorVersionUpgrade",
stack,
)?);
}
"AutomaticFailover" => {
obj.automatic_failover =
Some(AutomaticFailoverStatusDeserializer::deserialize(
"AutomaticFailover",
stack,
)?);
}
"CacheClusterCreateTime" => {
obj.cache_cluster_create_time = Some(TStampDeserializer::deserialize(
"CacheClusterCreateTime",
stack,
)?);
}
"CacheClusterId" => {
obj.cache_cluster_id =
Some(StringDeserializer::deserialize("CacheClusterId", stack)?);
}
"CacheNodeType" => {
obj.cache_node_type =
Some(StringDeserializer::deserialize("CacheNodeType", stack)?);
}
"CacheParameterGroupName" => {
obj.cache_parameter_group_name = Some(StringDeserializer::deserialize(
"CacheParameterGroupName",
stack,
)?);
}
"CacheSubnetGroupName" => {
obj.cache_subnet_group_name = Some(StringDeserializer::deserialize(
"CacheSubnetGroupName",
stack,
)?);
}
"Engine" => {
obj.engine = Some(StringDeserializer::deserialize("Engine", stack)?);
}
"EngineVersion" => {
obj.engine_version =
Some(StringDeserializer::deserialize("EngineVersion", stack)?);
}
"KmsKeyId" => {
obj.kms_key_id = Some(StringDeserializer::deserialize("KmsKeyId", stack)?);
}
"NodeSnapshots" => {
obj.node_snapshots.get_or_insert(vec![]).extend(
NodeSnapshotListDeserializer::deserialize("NodeSnapshots", stack)?,
);
}
"NumCacheNodes" => {
obj.num_cache_nodes = Some(IntegerOptionalDeserializer::deserialize(
"NumCacheNodes",
stack,
)?);
}
"NumNodeGroups" => {
obj.num_node_groups = Some(IntegerOptionalDeserializer::deserialize(
"NumNodeGroups",
stack,
)?);
}
"Port" => {
obj.port = Some(IntegerOptionalDeserializer::deserialize("Port", stack)?);
}
"PreferredAvailabilityZone" => {
obj.preferred_availability_zone = Some(StringDeserializer::deserialize(
"PreferredAvailabilityZone",
stack,
)?);
}
"PreferredMaintenanceWindow" => {
obj.preferred_maintenance_window = Some(StringDeserializer::deserialize(
"PreferredMaintenanceWindow",
stack,
)?);
}
"ReplicationGroupDescription" => {
obj.replication_group_description = Some(StringDeserializer::deserialize(
"ReplicationGroupDescription",
stack,
)?);
}
"ReplicationGroupId" => {
obj.replication_group_id = Some(StringDeserializer::deserialize(
"ReplicationGroupId",
stack,
)?);
}
"SnapshotName" => {
obj.snapshot_name =
Some(StringDeserializer::deserialize("SnapshotName", stack)?);
}
"SnapshotRetentionLimit" => {
obj.snapshot_retention_limit = Some(IntegerOptionalDeserializer::deserialize(
"SnapshotRetentionLimit",
stack,
)?);
}
"SnapshotSource" => {
obj.snapshot_source =
Some(StringDeserializer::deserialize("SnapshotSource", stack)?);
}
"SnapshotStatus" => {
obj.snapshot_status =
Some(StringDeserializer::deserialize("SnapshotStatus", stack)?);
}
"SnapshotWindow" => {
obj.snapshot_window =
Some(StringDeserializer::deserialize("SnapshotWindow", stack)?);
}
"TopicArn" => {
obj.topic_arn = Some(StringDeserializer::deserialize("TopicArn", stack)?);
}
"VpcId" => {
obj.vpc_id = Some(StringDeserializer::deserialize("VpcId", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct SnapshotArnsListSerializer;
impl SnapshotArnsListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.member.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
#[allow(dead_code)]
struct SnapshotListDeserializer;
impl SnapshotListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<Snapshot>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "Snapshot" {
obj.push(SnapshotDeserializer::deserialize("Snapshot", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[allow(dead_code)]
struct SourceTypeDeserializer;
impl SourceTypeDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct StartMigrationMessage {
pub customer_node_endpoint_list: Vec<CustomerNodeEndpoint>,
pub replication_group_id: String,
}
struct StartMigrationMessageSerializer;
impl StartMigrationMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &StartMigrationMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
CustomerNodeEndpointListSerializer::serialize(
params,
&format!("{}{}", prefix, "CustomerNodeEndpointList"),
&obj.customer_node_endpoint_list,
);
params.put(
&format!("{}{}", prefix, "ReplicationGroupId"),
&obj.replication_group_id,
);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct StartMigrationResponse {
pub replication_group: Option<ReplicationGroup>,
}
#[allow(dead_code)]
struct StartMigrationResponseDeserializer;
impl StartMigrationResponseDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<StartMigrationResponse, XmlParseError> {
deserialize_elements::<_, StartMigrationResponse, _>(tag_name, stack, |name, stack, obj| {
match name {
"ReplicationGroup" => {
obj.replication_group = Some(ReplicationGroupDeserializer::deserialize(
"ReplicationGroup",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[allow(dead_code)]
struct StringDeserializer;
impl StringDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct Subnet {
pub subnet_availability_zone: Option<AvailabilityZone>,
pub subnet_identifier: Option<String>,
}
#[allow(dead_code)]
struct SubnetDeserializer;
impl SubnetDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<Subnet, XmlParseError> {
deserialize_elements::<_, Subnet, _>(tag_name, stack, |name, stack, obj| {
match name {
"SubnetAvailabilityZone" => {
obj.subnet_availability_zone = Some(AvailabilityZoneDeserializer::deserialize(
"SubnetAvailabilityZone",
stack,
)?);
}
"SubnetIdentifier" => {
obj.subnet_identifier =
Some(StringDeserializer::deserialize("SubnetIdentifier", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct SubnetIdentifierListSerializer;
impl SubnetIdentifierListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.member.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
#[allow(dead_code)]
struct SubnetListDeserializer;
impl SubnetListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<Subnet>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "Subnet" {
obj.push(SubnetDeserializer::deserialize("Subnet", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[allow(dead_code)]
struct TStampDeserializer;
impl TStampDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct Tag {
pub key: Option<String>,
pub value: Option<String>,
}
#[allow(dead_code)]
struct TagDeserializer;
impl TagDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<Tag, XmlParseError> {
deserialize_elements::<_, Tag, _>(tag_name, stack, |name, stack, obj| {
match name {
"Key" => {
obj.key = Some(StringDeserializer::deserialize("Key", stack)?);
}
"Value" => {
obj.value = Some(StringDeserializer::deserialize("Value", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct TagSerializer;
impl TagSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Tag) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.key {
params.put(&format!("{}{}", prefix, "Key"), &field_value);
}
if let Some(ref field_value) = obj.value {
params.put(&format!("{}{}", prefix, "Value"), &field_value);
}
}
}
#[allow(dead_code)]
struct TagListDeserializer;
impl TagListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<Tag>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "Tag" {
obj.push(TagDeserializer::deserialize("Tag", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct TagListSerializer;
impl TagListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<Tag>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.member.{}", name, index + 1);
TagSerializer::serialize(params, &key, obj);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct TagListMessage {
pub tag_list: Option<Vec<Tag>>,
}
#[allow(dead_code)]
struct TagListMessageDeserializer;
impl TagListMessageDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<TagListMessage, XmlParseError> {
deserialize_elements::<_, TagListMessage, _>(tag_name, stack, |name, stack, obj| {
match name {
"TagList" => {
obj.tag_list
.get_or_insert(vec![])
.extend(TagListDeserializer::deserialize("TagList", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct TestFailoverMessage {
pub node_group_id: String,
pub replication_group_id: String,
}
struct TestFailoverMessageSerializer;
impl TestFailoverMessageSerializer {
fn serialize(params: &mut Params, name: &str, obj: &TestFailoverMessage) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(&format!("{}{}", prefix, "NodeGroupId"), &obj.node_group_id);
params.put(
&format!("{}{}", prefix, "ReplicationGroupId"),
&obj.replication_group_id,
);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct TestFailoverResult {
pub replication_group: Option<ReplicationGroup>,
}
#[allow(dead_code)]
struct TestFailoverResultDeserializer;
impl TestFailoverResultDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<TestFailoverResult, XmlParseError> {
deserialize_elements::<_, TestFailoverResult, _>(tag_name, stack, |name, stack, obj| {
match name {
"ReplicationGroup" => {
obj.replication_group = Some(ReplicationGroupDeserializer::deserialize(
"ReplicationGroup",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct TimeRangeFilter {
pub end_time: Option<String>,
pub start_time: Option<String>,
}
struct TimeRangeFilterSerializer;
impl TimeRangeFilterSerializer {
fn serialize(params: &mut Params, name: &str, obj: &TimeRangeFilter) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.end_time {
params.put(&format!("{}{}", prefix, "EndTime"), &field_value);
}
if let Some(ref field_value) = obj.start_time {
params.put(&format!("{}{}", prefix, "StartTime"), &field_value);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct UnprocessedUpdateAction {
pub cache_cluster_id: Option<String>,
pub error_message: Option<String>,
pub error_type: Option<String>,
pub replication_group_id: Option<String>,
pub service_update_name: Option<String>,
}
#[allow(dead_code)]
struct UnprocessedUpdateActionDeserializer;
impl UnprocessedUpdateActionDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<UnprocessedUpdateAction, XmlParseError> {
deserialize_elements::<_, UnprocessedUpdateAction, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"CacheClusterId" => {
obj.cache_cluster_id =
Some(StringDeserializer::deserialize("CacheClusterId", stack)?);
}
"ErrorMessage" => {
obj.error_message =
Some(StringDeserializer::deserialize("ErrorMessage", stack)?);
}
"ErrorType" => {
obj.error_type = Some(StringDeserializer::deserialize("ErrorType", stack)?);
}
"ReplicationGroupId" => {
obj.replication_group_id = Some(StringDeserializer::deserialize(
"ReplicationGroupId",
stack,
)?);
}
"ServiceUpdateName" => {
obj.service_update_name =
Some(StringDeserializer::deserialize("ServiceUpdateName", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[allow(dead_code)]
struct UnprocessedUpdateActionListDeserializer;
impl UnprocessedUpdateActionListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<UnprocessedUpdateAction>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "UnprocessedUpdateAction" {
obj.push(UnprocessedUpdateActionDeserializer::deserialize(
"UnprocessedUpdateAction",
stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct UpdateAction {
pub cache_cluster_id: Option<String>,
pub cache_node_update_status: Option<Vec<CacheNodeUpdateStatus>>,
pub engine: Option<String>,
pub estimated_update_time: Option<String>,
pub node_group_update_status: Option<Vec<NodeGroupUpdateStatus>>,
pub nodes_updated: Option<String>,
pub replication_group_id: Option<String>,
pub service_update_name: Option<String>,
pub service_update_recommended_apply_by_date: Option<String>,
pub service_update_release_date: Option<String>,
pub service_update_severity: Option<String>,
pub service_update_status: Option<String>,
pub service_update_type: Option<String>,
pub sla_met: Option<String>,
pub update_action_available_date: Option<String>,
pub update_action_status: Option<String>,
pub update_action_status_modified_date: Option<String>,
}
#[allow(dead_code)]
struct UpdateActionDeserializer;
impl UpdateActionDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<UpdateAction, XmlParseError> {
deserialize_elements::<_, UpdateAction, _>(tag_name, stack, |name, stack, obj| {
match name {
"CacheClusterId" => {
obj.cache_cluster_id =
Some(StringDeserializer::deserialize("CacheClusterId", stack)?);
}
"CacheNodeUpdateStatus" => {
obj.cache_node_update_status.get_or_insert(vec![]).extend(
CacheNodeUpdateStatusListDeserializer::deserialize(
"CacheNodeUpdateStatus",
stack,
)?,
);
}
"Engine" => {
obj.engine = Some(StringDeserializer::deserialize("Engine", stack)?);
}
"EstimatedUpdateTime" => {
obj.estimated_update_time = Some(StringDeserializer::deserialize(
"EstimatedUpdateTime",
stack,
)?);
}
"NodeGroupUpdateStatus" => {
obj.node_group_update_status.get_or_insert(vec![]).extend(
NodeGroupUpdateStatusListDeserializer::deserialize(
"NodeGroupUpdateStatus",
stack,
)?,
);
}
"NodesUpdated" => {
obj.nodes_updated =
Some(StringDeserializer::deserialize("NodesUpdated", stack)?);
}
"ReplicationGroupId" => {
obj.replication_group_id = Some(StringDeserializer::deserialize(
"ReplicationGroupId",
stack,
)?);
}
"ServiceUpdateName" => {
obj.service_update_name =
Some(StringDeserializer::deserialize("ServiceUpdateName", stack)?);
}
"ServiceUpdateRecommendedApplyByDate" => {
obj.service_update_recommended_apply_by_date =
Some(TStampDeserializer::deserialize(
"ServiceUpdateRecommendedApplyByDate",
stack,
)?);
}
"ServiceUpdateReleaseDate" => {
obj.service_update_release_date = Some(TStampDeserializer::deserialize(
"ServiceUpdateReleaseDate",
stack,
)?);
}
"ServiceUpdateSeverity" => {
obj.service_update_severity =
Some(ServiceUpdateSeverityDeserializer::deserialize(
"ServiceUpdateSeverity",
stack,
)?);
}
"ServiceUpdateStatus" => {
obj.service_update_status = Some(ServiceUpdateStatusDeserializer::deserialize(
"ServiceUpdateStatus",
stack,
)?);
}
"ServiceUpdateType" => {
obj.service_update_type = Some(ServiceUpdateTypeDeserializer::deserialize(
"ServiceUpdateType",
stack,
)?);
}
"SlaMet" => {
obj.sla_met = Some(SlaMetDeserializer::deserialize("SlaMet", stack)?);
}
"UpdateActionAvailableDate" => {
obj.update_action_available_date = Some(TStampDeserializer::deserialize(
"UpdateActionAvailableDate",
stack,
)?);
}
"UpdateActionStatus" => {
obj.update_action_status = Some(UpdateActionStatusDeserializer::deserialize(
"UpdateActionStatus",
stack,
)?);
}
"UpdateActionStatusModifiedDate" => {
obj.update_action_status_modified_date = Some(TStampDeserializer::deserialize(
"UpdateActionStatusModifiedDate",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[allow(dead_code)]
struct UpdateActionListDeserializer;
impl UpdateActionListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<UpdateAction>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "UpdateAction" {
obj.push(UpdateActionDeserializer::deserialize(
"UpdateAction",
stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct UpdateActionResultsMessage {
pub processed_update_actions: Option<Vec<ProcessedUpdateAction>>,
pub unprocessed_update_actions: Option<Vec<UnprocessedUpdateAction>>,
}
#[allow(dead_code)]
struct UpdateActionResultsMessageDeserializer;
impl UpdateActionResultsMessageDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<UpdateActionResultsMessage, XmlParseError> {
deserialize_elements::<_, UpdateActionResultsMessage, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"ProcessedUpdateActions" => {
obj.processed_update_actions.get_or_insert(vec![]).extend(
ProcessedUpdateActionListDeserializer::deserialize(
"ProcessedUpdateActions",
stack,
)?,
);
}
"UnprocessedUpdateActions" => {
obj.unprocessed_update_actions.get_or_insert(vec![]).extend(
UnprocessedUpdateActionListDeserializer::deserialize(
"UnprocessedUpdateActions",
stack,
)?,
);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[allow(dead_code)]
struct UpdateActionStatusDeserializer;
impl UpdateActionStatusDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
struct UpdateActionStatusListSerializer;
impl UpdateActionStatusListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.member.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct UpdateActionsMessage {
pub marker: Option<String>,
pub update_actions: Option<Vec<UpdateAction>>,
}
#[allow(dead_code)]
struct UpdateActionsMessageDeserializer;
impl UpdateActionsMessageDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<UpdateActionsMessage, XmlParseError> {
deserialize_elements::<_, UpdateActionsMessage, _>(tag_name, stack, |name, stack, obj| {
match name {
"Marker" => {
obj.marker = Some(StringDeserializer::deserialize("Marker", stack)?);
}
"UpdateActions" => {
obj.update_actions.get_or_insert(vec![]).extend(
UpdateActionListDeserializer::deserialize("UpdateActions", stack)?,
);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Debug, PartialEq)]
pub enum AddTagsToResourceError {
CacheClusterNotFoundFault(String),
InvalidARNFault(String),
SnapshotNotFoundFault(String),
TagQuotaPerResourceExceeded(String),
}
impl AddTagsToResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<AddTagsToResourceError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"CacheClusterNotFound" => {
return RusotoError::Service(
AddTagsToResourceError::CacheClusterNotFoundFault(parsed_error.message),
)
}
"InvalidARN" => {
return RusotoError::Service(AddTagsToResourceError::InvalidARNFault(
parsed_error.message,
))
}
"SnapshotNotFoundFault" => {
return RusotoError::Service(AddTagsToResourceError::SnapshotNotFoundFault(
parsed_error.message,
))
}
"TagQuotaPerResourceExceeded" => {
return RusotoError::Service(
AddTagsToResourceError::TagQuotaPerResourceExceeded(
parsed_error.message,
),
)
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for AddTagsToResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AddTagsToResourceError::CacheClusterNotFoundFault(ref cause) => write!(f, "{}", cause),
AddTagsToResourceError::InvalidARNFault(ref cause) => write!(f, "{}", cause),
AddTagsToResourceError::SnapshotNotFoundFault(ref cause) => write!(f, "{}", cause),
AddTagsToResourceError::TagQuotaPerResourceExceeded(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for AddTagsToResourceError {}
#[derive(Debug, PartialEq)]
pub enum AuthorizeCacheSecurityGroupIngressError {
AuthorizationAlreadyExistsFault(String),
CacheSecurityGroupNotFoundFault(String),
InvalidCacheSecurityGroupStateFault(String),
InvalidParameterCombination(String),
InvalidParameterValue(String),
}
impl AuthorizeCacheSecurityGroupIngressError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<AuthorizeCacheSecurityGroupIngressError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"AuthorizationAlreadyExists" => return RusotoError::Service(AuthorizeCacheSecurityGroupIngressError::AuthorizationAlreadyExistsFault(parsed_error.message)),"CacheSecurityGroupNotFound" => return RusotoError::Service(AuthorizeCacheSecurityGroupIngressError::CacheSecurityGroupNotFoundFault(parsed_error.message)),"InvalidCacheSecurityGroupState" => return RusotoError::Service(AuthorizeCacheSecurityGroupIngressError::InvalidCacheSecurityGroupStateFault(parsed_error.message)),"InvalidParameterCombination" => return RusotoError::Service(AuthorizeCacheSecurityGroupIngressError::InvalidParameterCombination(parsed_error.message)),"InvalidParameterValue" => return RusotoError::Service(AuthorizeCacheSecurityGroupIngressError::InvalidParameterValue(parsed_error.message)),_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for AuthorizeCacheSecurityGroupIngressError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AuthorizeCacheSecurityGroupIngressError::AuthorizationAlreadyExistsFault(ref cause) => {
write!(f, "{}", cause)
}
AuthorizeCacheSecurityGroupIngressError::CacheSecurityGroupNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
AuthorizeCacheSecurityGroupIngressError::InvalidCacheSecurityGroupStateFault(
ref cause,
) => write!(f, "{}", cause),
AuthorizeCacheSecurityGroupIngressError::InvalidParameterCombination(ref cause) => {
write!(f, "{}", cause)
}
AuthorizeCacheSecurityGroupIngressError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for AuthorizeCacheSecurityGroupIngressError {}
#[derive(Debug, PartialEq)]
pub enum BatchApplyUpdateActionError {
InvalidParameterValue(String),
ServiceUpdateNotFoundFault(String),
}
impl BatchApplyUpdateActionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<BatchApplyUpdateActionError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"InvalidParameterValue" => {
return RusotoError::Service(
BatchApplyUpdateActionError::InvalidParameterValue(
parsed_error.message,
),
)
}
"ServiceUpdateNotFoundFault" => {
return RusotoError::Service(
BatchApplyUpdateActionError::ServiceUpdateNotFoundFault(
parsed_error.message,
),
)
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for BatchApplyUpdateActionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
BatchApplyUpdateActionError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
BatchApplyUpdateActionError::ServiceUpdateNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for BatchApplyUpdateActionError {}
#[derive(Debug, PartialEq)]
pub enum BatchStopUpdateActionError {
InvalidParameterValue(String),
ServiceUpdateNotFoundFault(String),
}
impl BatchStopUpdateActionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<BatchStopUpdateActionError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"InvalidParameterValue" => {
return RusotoError::Service(
BatchStopUpdateActionError::InvalidParameterValue(parsed_error.message),
)
}
"ServiceUpdateNotFoundFault" => {
return RusotoError::Service(
BatchStopUpdateActionError::ServiceUpdateNotFoundFault(
parsed_error.message,
),
)
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for BatchStopUpdateActionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
BatchStopUpdateActionError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
BatchStopUpdateActionError::ServiceUpdateNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for BatchStopUpdateActionError {}
#[derive(Debug, PartialEq)]
pub enum CompleteMigrationError {
InvalidReplicationGroupStateFault(String),
ReplicationGroupNotFoundFault(String),
ReplicationGroupNotUnderMigrationFault(String),
}
impl CompleteMigrationError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CompleteMigrationError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"InvalidReplicationGroupState" => {
return RusotoError::Service(
CompleteMigrationError::InvalidReplicationGroupStateFault(
parsed_error.message,
),
)
}
"ReplicationGroupNotFoundFault" => {
return RusotoError::Service(
CompleteMigrationError::ReplicationGroupNotFoundFault(
parsed_error.message,
),
)
}
"ReplicationGroupNotUnderMigrationFault" => {
return RusotoError::Service(
CompleteMigrationError::ReplicationGroupNotUnderMigrationFault(
parsed_error.message,
),
)
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for CompleteMigrationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CompleteMigrationError::InvalidReplicationGroupStateFault(ref cause) => {
write!(f, "{}", cause)
}
CompleteMigrationError::ReplicationGroupNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
CompleteMigrationError::ReplicationGroupNotUnderMigrationFault(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for CompleteMigrationError {}
#[derive(Debug, PartialEq)]
pub enum CopySnapshotError {
InvalidParameterCombination(String),
InvalidParameterValue(String),
InvalidSnapshotStateFault(String),
SnapshotAlreadyExistsFault(String),
SnapshotNotFoundFault(String),
SnapshotQuotaExceededFault(String),
}
impl CopySnapshotError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CopySnapshotError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"InvalidParameterCombination" => {
return RusotoError::Service(
CopySnapshotError::InvalidParameterCombination(parsed_error.message),
)
}
"InvalidParameterValue" => {
return RusotoError::Service(CopySnapshotError::InvalidParameterValue(
parsed_error.message,
))
}
"InvalidSnapshotState" => {
return RusotoError::Service(CopySnapshotError::InvalidSnapshotStateFault(
parsed_error.message,
))
}
"SnapshotAlreadyExistsFault" => {
return RusotoError::Service(CopySnapshotError::SnapshotAlreadyExistsFault(
parsed_error.message,
))
}
"SnapshotNotFoundFault" => {
return RusotoError::Service(CopySnapshotError::SnapshotNotFoundFault(
parsed_error.message,
))
}
"SnapshotQuotaExceededFault" => {
return RusotoError::Service(CopySnapshotError::SnapshotQuotaExceededFault(
parsed_error.message,
))
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for CopySnapshotError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CopySnapshotError::InvalidParameterCombination(ref cause) => write!(f, "{}", cause),
CopySnapshotError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
CopySnapshotError::InvalidSnapshotStateFault(ref cause) => write!(f, "{}", cause),
CopySnapshotError::SnapshotAlreadyExistsFault(ref cause) => write!(f, "{}", cause),
CopySnapshotError::SnapshotNotFoundFault(ref cause) => write!(f, "{}", cause),
CopySnapshotError::SnapshotQuotaExceededFault(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CopySnapshotError {}
#[derive(Debug, PartialEq)]
pub enum CreateCacheClusterError {
CacheClusterAlreadyExistsFault(String),
CacheParameterGroupNotFoundFault(String),
CacheSecurityGroupNotFoundFault(String),
CacheSubnetGroupNotFoundFault(String),
ClusterQuotaForCustomerExceededFault(String),
InsufficientCacheClusterCapacityFault(String),
InvalidParameterCombination(String),
InvalidParameterValue(String),
InvalidReplicationGroupStateFault(String),
InvalidVPCNetworkStateFault(String),
NodeQuotaForClusterExceededFault(String),
NodeQuotaForCustomerExceededFault(String),
ReplicationGroupNotFoundFault(String),
TagQuotaPerResourceExceeded(String),
}
impl CreateCacheClusterError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateCacheClusterError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"CacheClusterAlreadyExists" => {
return RusotoError::Service(
CreateCacheClusterError::CacheClusterAlreadyExistsFault(
parsed_error.message,
),
)
}
"CacheParameterGroupNotFound" => {
return RusotoError::Service(
CreateCacheClusterError::CacheParameterGroupNotFoundFault(
parsed_error.message,
),
)
}
"CacheSecurityGroupNotFound" => {
return RusotoError::Service(
CreateCacheClusterError::CacheSecurityGroupNotFoundFault(
parsed_error.message,
),
)
}
"CacheSubnetGroupNotFoundFault" => {
return RusotoError::Service(
CreateCacheClusterError::CacheSubnetGroupNotFoundFault(
parsed_error.message,
),
)
}
"ClusterQuotaForCustomerExceeded" => {
return RusotoError::Service(
CreateCacheClusterError::ClusterQuotaForCustomerExceededFault(
parsed_error.message,
),
)
}
"InsufficientCacheClusterCapacity" => {
return RusotoError::Service(
CreateCacheClusterError::InsufficientCacheClusterCapacityFault(
parsed_error.message,
),
)
}
"InvalidParameterCombination" => {
return RusotoError::Service(
CreateCacheClusterError::InvalidParameterCombination(
parsed_error.message,
),
)
}
"InvalidParameterValue" => {
return RusotoError::Service(
CreateCacheClusterError::InvalidParameterValue(parsed_error.message),
)
}
"InvalidReplicationGroupState" => {
return RusotoError::Service(
CreateCacheClusterError::InvalidReplicationGroupStateFault(
parsed_error.message,
),
)
}
"InvalidVPCNetworkStateFault" => {
return RusotoError::Service(
CreateCacheClusterError::InvalidVPCNetworkStateFault(
parsed_error.message,
),
)
}
"NodeQuotaForClusterExceeded" => {
return RusotoError::Service(
CreateCacheClusterError::NodeQuotaForClusterExceededFault(
parsed_error.message,
),
)
}
"NodeQuotaForCustomerExceeded" => {
return RusotoError::Service(
CreateCacheClusterError::NodeQuotaForCustomerExceededFault(
parsed_error.message,
),
)
}
"ReplicationGroupNotFoundFault" => {
return RusotoError::Service(
CreateCacheClusterError::ReplicationGroupNotFoundFault(
parsed_error.message,
),
)
}
"TagQuotaPerResourceExceeded" => {
return RusotoError::Service(
CreateCacheClusterError::TagQuotaPerResourceExceeded(
parsed_error.message,
),
)
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for CreateCacheClusterError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateCacheClusterError::CacheClusterAlreadyExistsFault(ref cause) => {
write!(f, "{}", cause)
}
CreateCacheClusterError::CacheParameterGroupNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
CreateCacheClusterError::CacheSecurityGroupNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
CreateCacheClusterError::CacheSubnetGroupNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
CreateCacheClusterError::ClusterQuotaForCustomerExceededFault(ref cause) => {
write!(f, "{}", cause)
}
CreateCacheClusterError::InsufficientCacheClusterCapacityFault(ref cause) => {
write!(f, "{}", cause)
}
CreateCacheClusterError::InvalidParameterCombination(ref cause) => {
write!(f, "{}", cause)
}
CreateCacheClusterError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
CreateCacheClusterError::InvalidReplicationGroupStateFault(ref cause) => {
write!(f, "{}", cause)
}
CreateCacheClusterError::InvalidVPCNetworkStateFault(ref cause) => {
write!(f, "{}", cause)
}
CreateCacheClusterError::NodeQuotaForClusterExceededFault(ref cause) => {
write!(f, "{}", cause)
}
CreateCacheClusterError::NodeQuotaForCustomerExceededFault(ref cause) => {
write!(f, "{}", cause)
}
CreateCacheClusterError::ReplicationGroupNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
CreateCacheClusterError::TagQuotaPerResourceExceeded(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for CreateCacheClusterError {}
#[derive(Debug, PartialEq)]
pub enum CreateCacheParameterGroupError {
CacheParameterGroupAlreadyExistsFault(String),
CacheParameterGroupQuotaExceededFault(String),
InvalidCacheParameterGroupStateFault(String),
InvalidParameterCombination(String),
InvalidParameterValue(String),
}
impl CreateCacheParameterGroupError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateCacheParameterGroupError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"CacheParameterGroupAlreadyExists" => {
return RusotoError::Service(
CreateCacheParameterGroupError::CacheParameterGroupAlreadyExistsFault(
parsed_error.message,
),
)
}
"CacheParameterGroupQuotaExceeded" => {
return RusotoError::Service(
CreateCacheParameterGroupError::CacheParameterGroupQuotaExceededFault(
parsed_error.message,
),
)
}
"InvalidCacheParameterGroupState" => {
return RusotoError::Service(
CreateCacheParameterGroupError::InvalidCacheParameterGroupStateFault(
parsed_error.message,
),
)
}
"InvalidParameterCombination" => {
return RusotoError::Service(
CreateCacheParameterGroupError::InvalidParameterCombination(
parsed_error.message,
),
)
}
"InvalidParameterValue" => {
return RusotoError::Service(
CreateCacheParameterGroupError::InvalidParameterValue(
parsed_error.message,
),
)
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for CreateCacheParameterGroupError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateCacheParameterGroupError::CacheParameterGroupAlreadyExistsFault(ref cause) => {
write!(f, "{}", cause)
}
CreateCacheParameterGroupError::CacheParameterGroupQuotaExceededFault(ref cause) => {
write!(f, "{}", cause)
}
CreateCacheParameterGroupError::InvalidCacheParameterGroupStateFault(ref cause) => {
write!(f, "{}", cause)
}
CreateCacheParameterGroupError::InvalidParameterCombination(ref cause) => {
write!(f, "{}", cause)
}
CreateCacheParameterGroupError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for CreateCacheParameterGroupError {}
#[derive(Debug, PartialEq)]
pub enum CreateCacheSecurityGroupError {
CacheSecurityGroupAlreadyExistsFault(String),
CacheSecurityGroupQuotaExceededFault(String),
InvalidParameterCombination(String),
InvalidParameterValue(String),
}
impl CreateCacheSecurityGroupError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateCacheSecurityGroupError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"CacheSecurityGroupAlreadyExists" => {
return RusotoError::Service(
CreateCacheSecurityGroupError::CacheSecurityGroupAlreadyExistsFault(
parsed_error.message,
),
)
}
"QuotaExceeded.CacheSecurityGroup" => {
return RusotoError::Service(
CreateCacheSecurityGroupError::CacheSecurityGroupQuotaExceededFault(
parsed_error.message,
),
)
}
"InvalidParameterCombination" => {
return RusotoError::Service(
CreateCacheSecurityGroupError::InvalidParameterCombination(
parsed_error.message,
),
)
}
"InvalidParameterValue" => {
return RusotoError::Service(
CreateCacheSecurityGroupError::InvalidParameterValue(
parsed_error.message,
),
)
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for CreateCacheSecurityGroupError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateCacheSecurityGroupError::CacheSecurityGroupAlreadyExistsFault(ref cause) => {
write!(f, "{}", cause)
}
CreateCacheSecurityGroupError::CacheSecurityGroupQuotaExceededFault(ref cause) => {
write!(f, "{}", cause)
}
CreateCacheSecurityGroupError::InvalidParameterCombination(ref cause) => {
write!(f, "{}", cause)
}
CreateCacheSecurityGroupError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for CreateCacheSecurityGroupError {}
#[derive(Debug, PartialEq)]
pub enum CreateCacheSubnetGroupError {
CacheSubnetGroupAlreadyExistsFault(String),
CacheSubnetGroupQuotaExceededFault(String),
CacheSubnetQuotaExceededFault(String),
InvalidSubnet(String),
}
impl CreateCacheSubnetGroupError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateCacheSubnetGroupError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"CacheSubnetGroupAlreadyExists" => {
return RusotoError::Service(
CreateCacheSubnetGroupError::CacheSubnetGroupAlreadyExistsFault(
parsed_error.message,
),
)
}
"CacheSubnetGroupQuotaExceeded" => {
return RusotoError::Service(
CreateCacheSubnetGroupError::CacheSubnetGroupQuotaExceededFault(
parsed_error.message,
),
)
}
"CacheSubnetQuotaExceededFault" => {
return RusotoError::Service(
CreateCacheSubnetGroupError::CacheSubnetQuotaExceededFault(
parsed_error.message,
),
)
}
"InvalidSubnet" => {
return RusotoError::Service(CreateCacheSubnetGroupError::InvalidSubnet(
parsed_error.message,
))
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for CreateCacheSubnetGroupError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateCacheSubnetGroupError::CacheSubnetGroupAlreadyExistsFault(ref cause) => {
write!(f, "{}", cause)
}
CreateCacheSubnetGroupError::CacheSubnetGroupQuotaExceededFault(ref cause) => {
write!(f, "{}", cause)
}
CreateCacheSubnetGroupError::CacheSubnetQuotaExceededFault(ref cause) => {
write!(f, "{}", cause)
}
CreateCacheSubnetGroupError::InvalidSubnet(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateCacheSubnetGroupError {}
#[derive(Debug, PartialEq)]
pub enum CreateGlobalReplicationGroupError {
GlobalReplicationGroupAlreadyExistsFault(String),
InvalidParameterValue(String),
InvalidReplicationGroupStateFault(String),
ReplicationGroupNotFoundFault(String),
ServiceLinkedRoleNotFoundFault(String),
}
impl CreateGlobalReplicationGroupError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<CreateGlobalReplicationGroupError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"GlobalReplicationGroupAlreadyExistsFault" => return RusotoError::Service(
CreateGlobalReplicationGroupError::GlobalReplicationGroupAlreadyExistsFault(
parsed_error.message,
),
),
"InvalidParameterValue" => {
return RusotoError::Service(
CreateGlobalReplicationGroupError::InvalidParameterValue(
parsed_error.message,
),
)
}
"InvalidReplicationGroupState" => {
return RusotoError::Service(
CreateGlobalReplicationGroupError::InvalidReplicationGroupStateFault(
parsed_error.message,
),
)
}
"ReplicationGroupNotFoundFault" => {
return RusotoError::Service(
CreateGlobalReplicationGroupError::ReplicationGroupNotFoundFault(
parsed_error.message,
),
)
}
"ServiceLinkedRoleNotFoundFault" => {
return RusotoError::Service(
CreateGlobalReplicationGroupError::ServiceLinkedRoleNotFoundFault(
parsed_error.message,
),
)
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for CreateGlobalReplicationGroupError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateGlobalReplicationGroupError::GlobalReplicationGroupAlreadyExistsFault(
ref cause,
) => write!(f, "{}", cause),
CreateGlobalReplicationGroupError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
CreateGlobalReplicationGroupError::InvalidReplicationGroupStateFault(ref cause) => {
write!(f, "{}", cause)
}
CreateGlobalReplicationGroupError::ReplicationGroupNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
CreateGlobalReplicationGroupError::ServiceLinkedRoleNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for CreateGlobalReplicationGroupError {}
#[derive(Debug, PartialEq)]
pub enum CreateReplicationGroupError {
CacheClusterNotFoundFault(String),
CacheParameterGroupNotFoundFault(String),
CacheSecurityGroupNotFoundFault(String),
CacheSubnetGroupNotFoundFault(String),
ClusterQuotaForCustomerExceededFault(String),
GlobalReplicationGroupNotFoundFault(String),
InsufficientCacheClusterCapacityFault(String),
InvalidCacheClusterStateFault(String),
InvalidGlobalReplicationGroupStateFault(String),
InvalidParameterCombination(String),
InvalidParameterValue(String),
InvalidVPCNetworkStateFault(String),
NodeGroupsPerReplicationGroupQuotaExceededFault(String),
NodeQuotaForClusterExceededFault(String),
NodeQuotaForCustomerExceededFault(String),
ReplicationGroupAlreadyExistsFault(String),
TagQuotaPerResourceExceeded(String),
}
impl CreateReplicationGroupError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateReplicationGroupError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"CacheClusterNotFound" => return RusotoError::Service(CreateReplicationGroupError::CacheClusterNotFoundFault(parsed_error.message)),"CacheParameterGroupNotFound" => return RusotoError::Service(CreateReplicationGroupError::CacheParameterGroupNotFoundFault(parsed_error.message)),"CacheSecurityGroupNotFound" => return RusotoError::Service(CreateReplicationGroupError::CacheSecurityGroupNotFoundFault(parsed_error.message)),"CacheSubnetGroupNotFoundFault" => return RusotoError::Service(CreateReplicationGroupError::CacheSubnetGroupNotFoundFault(parsed_error.message)),"ClusterQuotaForCustomerExceeded" => return RusotoError::Service(CreateReplicationGroupError::ClusterQuotaForCustomerExceededFault(parsed_error.message)),"GlobalReplicationGroupNotFoundFault" => return RusotoError::Service(CreateReplicationGroupError::GlobalReplicationGroupNotFoundFault(parsed_error.message)),"InsufficientCacheClusterCapacity" => return RusotoError::Service(CreateReplicationGroupError::InsufficientCacheClusterCapacityFault(parsed_error.message)),"InvalidCacheClusterState" => return RusotoError::Service(CreateReplicationGroupError::InvalidCacheClusterStateFault(parsed_error.message)),"InvalidGlobalReplicationGroupState" => return RusotoError::Service(CreateReplicationGroupError::InvalidGlobalReplicationGroupStateFault(parsed_error.message)),"InvalidParameterCombination" => return RusotoError::Service(CreateReplicationGroupError::InvalidParameterCombination(parsed_error.message)),"InvalidParameterValue" => return RusotoError::Service(CreateReplicationGroupError::InvalidParameterValue(parsed_error.message)),"InvalidVPCNetworkStateFault" => return RusotoError::Service(CreateReplicationGroupError::InvalidVPCNetworkStateFault(parsed_error.message)),"NodeGroupsPerReplicationGroupQuotaExceeded" => return RusotoError::Service(CreateReplicationGroupError::NodeGroupsPerReplicationGroupQuotaExceededFault(parsed_error.message)),"NodeQuotaForClusterExceeded" => return RusotoError::Service(CreateReplicationGroupError::NodeQuotaForClusterExceededFault(parsed_error.message)),"NodeQuotaForCustomerExceeded" => return RusotoError::Service(CreateReplicationGroupError::NodeQuotaForCustomerExceededFault(parsed_error.message)),"ReplicationGroupAlreadyExists" => return RusotoError::Service(CreateReplicationGroupError::ReplicationGroupAlreadyExistsFault(parsed_error.message)),"TagQuotaPerResourceExceeded" => return RusotoError::Service(CreateReplicationGroupError::TagQuotaPerResourceExceeded(parsed_error.message)),_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for CreateReplicationGroupError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateReplicationGroupError::CacheClusterNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
CreateReplicationGroupError::CacheParameterGroupNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
CreateReplicationGroupError::CacheSecurityGroupNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
CreateReplicationGroupError::CacheSubnetGroupNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
CreateReplicationGroupError::ClusterQuotaForCustomerExceededFault(ref cause) => {
write!(f, "{}", cause)
}
CreateReplicationGroupError::GlobalReplicationGroupNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
CreateReplicationGroupError::InsufficientCacheClusterCapacityFault(ref cause) => {
write!(f, "{}", cause)
}
CreateReplicationGroupError::InvalidCacheClusterStateFault(ref cause) => {
write!(f, "{}", cause)
}
CreateReplicationGroupError::InvalidGlobalReplicationGroupStateFault(ref cause) => {
write!(f, "{}", cause)
}
CreateReplicationGroupError::InvalidParameterCombination(ref cause) => {
write!(f, "{}", cause)
}
CreateReplicationGroupError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
CreateReplicationGroupError::InvalidVPCNetworkStateFault(ref cause) => {
write!(f, "{}", cause)
}
CreateReplicationGroupError::NodeGroupsPerReplicationGroupQuotaExceededFault(
ref cause,
) => write!(f, "{}", cause),
CreateReplicationGroupError::NodeQuotaForClusterExceededFault(ref cause) => {
write!(f, "{}", cause)
}
CreateReplicationGroupError::NodeQuotaForCustomerExceededFault(ref cause) => {
write!(f, "{}", cause)
}
CreateReplicationGroupError::ReplicationGroupAlreadyExistsFault(ref cause) => {
write!(f, "{}", cause)
}
CreateReplicationGroupError::TagQuotaPerResourceExceeded(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for CreateReplicationGroupError {}
#[derive(Debug, PartialEq)]
pub enum CreateSnapshotError {
CacheClusterNotFoundFault(String),
InvalidCacheClusterStateFault(String),
InvalidParameterCombination(String),
InvalidParameterValue(String),
InvalidReplicationGroupStateFault(String),
ReplicationGroupNotFoundFault(String),
SnapshotAlreadyExistsFault(String),
SnapshotFeatureNotSupportedFault(String),
SnapshotQuotaExceededFault(String),
}
impl CreateSnapshotError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateSnapshotError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"CacheClusterNotFound" => {
return RusotoError::Service(
CreateSnapshotError::CacheClusterNotFoundFault(parsed_error.message),
)
}
"InvalidCacheClusterState" => {
return RusotoError::Service(
CreateSnapshotError::InvalidCacheClusterStateFault(
parsed_error.message,
),
)
}
"InvalidParameterCombination" => {
return RusotoError::Service(
CreateSnapshotError::InvalidParameterCombination(parsed_error.message),
)
}
"InvalidParameterValue" => {
return RusotoError::Service(CreateSnapshotError::InvalidParameterValue(
parsed_error.message,
))
}
"InvalidReplicationGroupState" => {
return RusotoError::Service(
CreateSnapshotError::InvalidReplicationGroupStateFault(
parsed_error.message,
),
)
}
"ReplicationGroupNotFoundFault" => {
return RusotoError::Service(
CreateSnapshotError::ReplicationGroupNotFoundFault(
parsed_error.message,
),
)
}
"SnapshotAlreadyExistsFault" => {
return RusotoError::Service(
CreateSnapshotError::SnapshotAlreadyExistsFault(parsed_error.message),
)
}
"SnapshotFeatureNotSupportedFault" => {
return RusotoError::Service(
CreateSnapshotError::SnapshotFeatureNotSupportedFault(
parsed_error.message,
),
)
}
"SnapshotQuotaExceededFault" => {
return RusotoError::Service(
CreateSnapshotError::SnapshotQuotaExceededFault(parsed_error.message),
)
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for CreateSnapshotError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateSnapshotError::CacheClusterNotFoundFault(ref cause) => write!(f, "{}", cause),
CreateSnapshotError::InvalidCacheClusterStateFault(ref cause) => write!(f, "{}", cause),
CreateSnapshotError::InvalidParameterCombination(ref cause) => write!(f, "{}", cause),
CreateSnapshotError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
CreateSnapshotError::InvalidReplicationGroupStateFault(ref cause) => {
write!(f, "{}", cause)
}
CreateSnapshotError::ReplicationGroupNotFoundFault(ref cause) => write!(f, "{}", cause),
CreateSnapshotError::SnapshotAlreadyExistsFault(ref cause) => write!(f, "{}", cause),
CreateSnapshotError::SnapshotFeatureNotSupportedFault(ref cause) => {
write!(f, "{}", cause)
}
CreateSnapshotError::SnapshotQuotaExceededFault(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateSnapshotError {}
#[derive(Debug, PartialEq)]
pub enum DecreaseNodeGroupsInGlobalReplicationGroupError {
GlobalReplicationGroupNotFoundFault(String),
InvalidGlobalReplicationGroupStateFault(String),
InvalidParameterCombination(String),
InvalidParameterValue(String),
}
impl DecreaseNodeGroupsInGlobalReplicationGroupError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DecreaseNodeGroupsInGlobalReplicationGroupError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"GlobalReplicationGroupNotFoundFault" => return RusotoError::Service(DecreaseNodeGroupsInGlobalReplicationGroupError::GlobalReplicationGroupNotFoundFault(parsed_error.message)),"InvalidGlobalReplicationGroupState" => return RusotoError::Service(DecreaseNodeGroupsInGlobalReplicationGroupError::InvalidGlobalReplicationGroupStateFault(parsed_error.message)),"InvalidParameterCombination" => return RusotoError::Service(DecreaseNodeGroupsInGlobalReplicationGroupError::InvalidParameterCombination(parsed_error.message)),"InvalidParameterValue" => return RusotoError::Service(DecreaseNodeGroupsInGlobalReplicationGroupError::InvalidParameterValue(parsed_error.message)),_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DecreaseNodeGroupsInGlobalReplicationGroupError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DecreaseNodeGroupsInGlobalReplicationGroupError::GlobalReplicationGroupNotFoundFault(ref cause) => write!(f, "{}", cause),
DecreaseNodeGroupsInGlobalReplicationGroupError::InvalidGlobalReplicationGroupStateFault(ref cause) => write!(f, "{}", cause),
DecreaseNodeGroupsInGlobalReplicationGroupError::InvalidParameterCombination(ref cause) => write!(f, "{}", cause),
DecreaseNodeGroupsInGlobalReplicationGroupError::InvalidParameterValue(ref cause) => write!(f, "{}", cause)
}
}
}
impl Error for DecreaseNodeGroupsInGlobalReplicationGroupError {}
#[derive(Debug, PartialEq)]
pub enum DecreaseReplicaCountError {
ClusterQuotaForCustomerExceededFault(String),
InsufficientCacheClusterCapacityFault(String),
InvalidCacheClusterStateFault(String),
InvalidParameterCombination(String),
InvalidParameterValue(String),
InvalidReplicationGroupStateFault(String),
InvalidVPCNetworkStateFault(String),
NoOperationFault(String),
NodeGroupsPerReplicationGroupQuotaExceededFault(String),
NodeQuotaForCustomerExceededFault(String),
ReplicationGroupNotFoundFault(String),
ServiceLinkedRoleNotFoundFault(String),
}
impl DecreaseReplicaCountError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DecreaseReplicaCountError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"ClusterQuotaForCustomerExceeded" => {
return RusotoError::Service(
DecreaseReplicaCountError::ClusterQuotaForCustomerExceededFault(
parsed_error.message,
),
)
}
"InsufficientCacheClusterCapacity" => {
return RusotoError::Service(
DecreaseReplicaCountError::InsufficientCacheClusterCapacityFault(
parsed_error.message,
),
)
}
"InvalidCacheClusterState" => {
return RusotoError::Service(
DecreaseReplicaCountError::InvalidCacheClusterStateFault(
parsed_error.message,
),
)
}
"InvalidParameterCombination" => {
return RusotoError::Service(
DecreaseReplicaCountError::InvalidParameterCombination(
parsed_error.message,
),
)
}
"InvalidParameterValue" => {
return RusotoError::Service(
DecreaseReplicaCountError::InvalidParameterValue(parsed_error.message),
)
}
"InvalidReplicationGroupState" => {
return RusotoError::Service(
DecreaseReplicaCountError::InvalidReplicationGroupStateFault(
parsed_error.message,
),
)
}
"InvalidVPCNetworkStateFault" => {
return RusotoError::Service(
DecreaseReplicaCountError::InvalidVPCNetworkStateFault(
parsed_error.message,
),
)
}
"NoOperationFault" => {
return RusotoError::Service(DecreaseReplicaCountError::NoOperationFault(
parsed_error.message,
))
}
"NodeGroupsPerReplicationGroupQuotaExceeded" => return RusotoError::Service(
DecreaseReplicaCountError::NodeGroupsPerReplicationGroupQuotaExceededFault(
parsed_error.message,
),
),
"NodeQuotaForCustomerExceeded" => {
return RusotoError::Service(
DecreaseReplicaCountError::NodeQuotaForCustomerExceededFault(
parsed_error.message,
),
)
}
"ReplicationGroupNotFoundFault" => {
return RusotoError::Service(
DecreaseReplicaCountError::ReplicationGroupNotFoundFault(
parsed_error.message,
),
)
}
"ServiceLinkedRoleNotFoundFault" => {
return RusotoError::Service(
DecreaseReplicaCountError::ServiceLinkedRoleNotFoundFault(
parsed_error.message,
),
)
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DecreaseReplicaCountError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DecreaseReplicaCountError::ClusterQuotaForCustomerExceededFault(ref cause) => {
write!(f, "{}", cause)
}
DecreaseReplicaCountError::InsufficientCacheClusterCapacityFault(ref cause) => {
write!(f, "{}", cause)
}
DecreaseReplicaCountError::InvalidCacheClusterStateFault(ref cause) => {
write!(f, "{}", cause)
}
DecreaseReplicaCountError::InvalidParameterCombination(ref cause) => {
write!(f, "{}", cause)
}
DecreaseReplicaCountError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
DecreaseReplicaCountError::InvalidReplicationGroupStateFault(ref cause) => {
write!(f, "{}", cause)
}
DecreaseReplicaCountError::InvalidVPCNetworkStateFault(ref cause) => {
write!(f, "{}", cause)
}
DecreaseReplicaCountError::NoOperationFault(ref cause) => write!(f, "{}", cause),
DecreaseReplicaCountError::NodeGroupsPerReplicationGroupQuotaExceededFault(
ref cause,
) => write!(f, "{}", cause),
DecreaseReplicaCountError::NodeQuotaForCustomerExceededFault(ref cause) => {
write!(f, "{}", cause)
}
DecreaseReplicaCountError::ReplicationGroupNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
DecreaseReplicaCountError::ServiceLinkedRoleNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DecreaseReplicaCountError {}
#[derive(Debug, PartialEq)]
pub enum DeleteCacheClusterError {
CacheClusterNotFoundFault(String),
InvalidCacheClusterStateFault(String),
InvalidParameterCombination(String),
InvalidParameterValue(String),
SnapshotAlreadyExistsFault(String),
SnapshotFeatureNotSupportedFault(String),
SnapshotQuotaExceededFault(String),
}
impl DeleteCacheClusterError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteCacheClusterError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"CacheClusterNotFound" => {
return RusotoError::Service(
DeleteCacheClusterError::CacheClusterNotFoundFault(
parsed_error.message,
),
)
}
"InvalidCacheClusterState" => {
return RusotoError::Service(
DeleteCacheClusterError::InvalidCacheClusterStateFault(
parsed_error.message,
),
)
}
"InvalidParameterCombination" => {
return RusotoError::Service(
DeleteCacheClusterError::InvalidParameterCombination(
parsed_error.message,
),
)
}
"InvalidParameterValue" => {
return RusotoError::Service(
DeleteCacheClusterError::InvalidParameterValue(parsed_error.message),
)
}
"SnapshotAlreadyExistsFault" => {
return RusotoError::Service(
DeleteCacheClusterError::SnapshotAlreadyExistsFault(
parsed_error.message,
),
)
}
"SnapshotFeatureNotSupportedFault" => {
return RusotoError::Service(
DeleteCacheClusterError::SnapshotFeatureNotSupportedFault(
parsed_error.message,
),
)
}
"SnapshotQuotaExceededFault" => {
return RusotoError::Service(
DeleteCacheClusterError::SnapshotQuotaExceededFault(
parsed_error.message,
),
)
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DeleteCacheClusterError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteCacheClusterError::CacheClusterNotFoundFault(ref cause) => write!(f, "{}", cause),
DeleteCacheClusterError::InvalidCacheClusterStateFault(ref cause) => {
write!(f, "{}", cause)
}
DeleteCacheClusterError::InvalidParameterCombination(ref cause) => {
write!(f, "{}", cause)
}
DeleteCacheClusterError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
DeleteCacheClusterError::SnapshotAlreadyExistsFault(ref cause) => {
write!(f, "{}", cause)
}
DeleteCacheClusterError::SnapshotFeatureNotSupportedFault(ref cause) => {
write!(f, "{}", cause)
}
DeleteCacheClusterError::SnapshotQuotaExceededFault(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DeleteCacheClusterError {}
#[derive(Debug, PartialEq)]
pub enum DeleteCacheParameterGroupError {
CacheParameterGroupNotFoundFault(String),
InvalidCacheParameterGroupStateFault(String),
InvalidParameterCombination(String),
InvalidParameterValue(String),
}
impl DeleteCacheParameterGroupError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteCacheParameterGroupError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"CacheParameterGroupNotFound" => {
return RusotoError::Service(
DeleteCacheParameterGroupError::CacheParameterGroupNotFoundFault(
parsed_error.message,
),
)
}
"InvalidCacheParameterGroupState" => {
return RusotoError::Service(
DeleteCacheParameterGroupError::InvalidCacheParameterGroupStateFault(
parsed_error.message,
),
)
}
"InvalidParameterCombination" => {
return RusotoError::Service(
DeleteCacheParameterGroupError::InvalidParameterCombination(
parsed_error.message,
),
)
}
"InvalidParameterValue" => {
return RusotoError::Service(
DeleteCacheParameterGroupError::InvalidParameterValue(
parsed_error.message,
),
)
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DeleteCacheParameterGroupError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteCacheParameterGroupError::CacheParameterGroupNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
DeleteCacheParameterGroupError::InvalidCacheParameterGroupStateFault(ref cause) => {
write!(f, "{}", cause)
}
DeleteCacheParameterGroupError::InvalidParameterCombination(ref cause) => {
write!(f, "{}", cause)
}
DeleteCacheParameterGroupError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DeleteCacheParameterGroupError {}
#[derive(Debug, PartialEq)]
pub enum DeleteCacheSecurityGroupError {
CacheSecurityGroupNotFoundFault(String),
InvalidCacheSecurityGroupStateFault(String),
InvalidParameterCombination(String),
InvalidParameterValue(String),
}
impl DeleteCacheSecurityGroupError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteCacheSecurityGroupError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"CacheSecurityGroupNotFound" => {
return RusotoError::Service(
DeleteCacheSecurityGroupError::CacheSecurityGroupNotFoundFault(
parsed_error.message,
),
)
}
"InvalidCacheSecurityGroupState" => {
return RusotoError::Service(
DeleteCacheSecurityGroupError::InvalidCacheSecurityGroupStateFault(
parsed_error.message,
),
)
}
"InvalidParameterCombination" => {
return RusotoError::Service(
DeleteCacheSecurityGroupError::InvalidParameterCombination(
parsed_error.message,
),
)
}
"InvalidParameterValue" => {
return RusotoError::Service(
DeleteCacheSecurityGroupError::InvalidParameterValue(
parsed_error.message,
),
)
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DeleteCacheSecurityGroupError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteCacheSecurityGroupError::CacheSecurityGroupNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
DeleteCacheSecurityGroupError::InvalidCacheSecurityGroupStateFault(ref cause) => {
write!(f, "{}", cause)
}
DeleteCacheSecurityGroupError::InvalidParameterCombination(ref cause) => {
write!(f, "{}", cause)
}
DeleteCacheSecurityGroupError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DeleteCacheSecurityGroupError {}
#[derive(Debug, PartialEq)]
pub enum DeleteCacheSubnetGroupError {
CacheSubnetGroupInUse(String),
CacheSubnetGroupNotFoundFault(String),
}
impl DeleteCacheSubnetGroupError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteCacheSubnetGroupError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"CacheSubnetGroupInUse" => {
return RusotoError::Service(
DeleteCacheSubnetGroupError::CacheSubnetGroupInUse(
parsed_error.message,
),
)
}
"CacheSubnetGroupNotFoundFault" => {
return RusotoError::Service(
DeleteCacheSubnetGroupError::CacheSubnetGroupNotFoundFault(
parsed_error.message,
),
)
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DeleteCacheSubnetGroupError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteCacheSubnetGroupError::CacheSubnetGroupInUse(ref cause) => write!(f, "{}", cause),
DeleteCacheSubnetGroupError::CacheSubnetGroupNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DeleteCacheSubnetGroupError {}
#[derive(Debug, PartialEq)]
pub enum DeleteGlobalReplicationGroupError {
GlobalReplicationGroupNotFoundFault(String),
InvalidGlobalReplicationGroupStateFault(String),
InvalidParameterValue(String),
}
impl DeleteGlobalReplicationGroupError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DeleteGlobalReplicationGroupError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"GlobalReplicationGroupNotFoundFault" => {
return RusotoError::Service(
DeleteGlobalReplicationGroupError::GlobalReplicationGroupNotFoundFault(
parsed_error.message,
),
)
}
"InvalidGlobalReplicationGroupState" => return RusotoError::Service(
DeleteGlobalReplicationGroupError::InvalidGlobalReplicationGroupStateFault(
parsed_error.message,
),
),
"InvalidParameterValue" => {
return RusotoError::Service(
DeleteGlobalReplicationGroupError::InvalidParameterValue(
parsed_error.message,
),
)
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DeleteGlobalReplicationGroupError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteGlobalReplicationGroupError::GlobalReplicationGroupNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
DeleteGlobalReplicationGroupError::InvalidGlobalReplicationGroupStateFault(
ref cause,
) => write!(f, "{}", cause),
DeleteGlobalReplicationGroupError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DeleteGlobalReplicationGroupError {}
#[derive(Debug, PartialEq)]
pub enum DeleteReplicationGroupError {
InvalidParameterCombination(String),
InvalidParameterValue(String),
InvalidReplicationGroupStateFault(String),
ReplicationGroupNotFoundFault(String),
SnapshotAlreadyExistsFault(String),
SnapshotFeatureNotSupportedFault(String),
SnapshotQuotaExceededFault(String),
}
impl DeleteReplicationGroupError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteReplicationGroupError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"InvalidParameterCombination" => {
return RusotoError::Service(
DeleteReplicationGroupError::InvalidParameterCombination(
parsed_error.message,
),
)
}
"InvalidParameterValue" => {
return RusotoError::Service(
DeleteReplicationGroupError::InvalidParameterValue(
parsed_error.message,
),
)
}
"InvalidReplicationGroupState" => {
return RusotoError::Service(
DeleteReplicationGroupError::InvalidReplicationGroupStateFault(
parsed_error.message,
),
)
}
"ReplicationGroupNotFoundFault" => {
return RusotoError::Service(
DeleteReplicationGroupError::ReplicationGroupNotFoundFault(
parsed_error.message,
),
)
}
"SnapshotAlreadyExistsFault" => {
return RusotoError::Service(
DeleteReplicationGroupError::SnapshotAlreadyExistsFault(
parsed_error.message,
),
)
}
"SnapshotFeatureNotSupportedFault" => {
return RusotoError::Service(
DeleteReplicationGroupError::SnapshotFeatureNotSupportedFault(
parsed_error.message,
),
)
}
"SnapshotQuotaExceededFault" => {
return RusotoError::Service(
DeleteReplicationGroupError::SnapshotQuotaExceededFault(
parsed_error.message,
),
)
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DeleteReplicationGroupError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteReplicationGroupError::InvalidParameterCombination(ref cause) => {
write!(f, "{}", cause)
}
DeleteReplicationGroupError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
DeleteReplicationGroupError::InvalidReplicationGroupStateFault(ref cause) => {
write!(f, "{}", cause)
}
DeleteReplicationGroupError::ReplicationGroupNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
DeleteReplicationGroupError::SnapshotAlreadyExistsFault(ref cause) => {
write!(f, "{}", cause)
}
DeleteReplicationGroupError::SnapshotFeatureNotSupportedFault(ref cause) => {
write!(f, "{}", cause)
}
DeleteReplicationGroupError::SnapshotQuotaExceededFault(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DeleteReplicationGroupError {}
#[derive(Debug, PartialEq)]
pub enum DeleteSnapshotError {
InvalidParameterCombination(String),
InvalidParameterValue(String),
InvalidSnapshotStateFault(String),
SnapshotNotFoundFault(String),
}
impl DeleteSnapshotError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteSnapshotError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"InvalidParameterCombination" => {
return RusotoError::Service(
DeleteSnapshotError::InvalidParameterCombination(parsed_error.message),
)
}
"InvalidParameterValue" => {
return RusotoError::Service(DeleteSnapshotError::InvalidParameterValue(
parsed_error.message,
))
}
"InvalidSnapshotState" => {
return RusotoError::Service(
DeleteSnapshotError::InvalidSnapshotStateFault(parsed_error.message),
)
}
"SnapshotNotFoundFault" => {
return RusotoError::Service(DeleteSnapshotError::SnapshotNotFoundFault(
parsed_error.message,
))
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DeleteSnapshotError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteSnapshotError::InvalidParameterCombination(ref cause) => write!(f, "{}", cause),
DeleteSnapshotError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
DeleteSnapshotError::InvalidSnapshotStateFault(ref cause) => write!(f, "{}", cause),
DeleteSnapshotError::SnapshotNotFoundFault(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteSnapshotError {}
#[derive(Debug, PartialEq)]
pub enum DescribeCacheClustersError {
CacheClusterNotFoundFault(String),
InvalidParameterCombination(String),
InvalidParameterValue(String),
}
impl DescribeCacheClustersError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeCacheClustersError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"CacheClusterNotFound" => {
return RusotoError::Service(
DescribeCacheClustersError::CacheClusterNotFoundFault(
parsed_error.message,
),
)
}
"InvalidParameterCombination" => {
return RusotoError::Service(
DescribeCacheClustersError::InvalidParameterCombination(
parsed_error.message,
),
)
}
"InvalidParameterValue" => {
return RusotoError::Service(
DescribeCacheClustersError::InvalidParameterValue(parsed_error.message),
)
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeCacheClustersError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeCacheClustersError::CacheClusterNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
DescribeCacheClustersError::InvalidParameterCombination(ref cause) => {
write!(f, "{}", cause)
}
DescribeCacheClustersError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeCacheClustersError {}
#[derive(Debug, PartialEq)]
pub enum DescribeCacheEngineVersionsError {}
impl DescribeCacheEngineVersionsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeCacheEngineVersionsError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeCacheEngineVersionsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {}
}
}
impl Error for DescribeCacheEngineVersionsError {}
#[derive(Debug, PartialEq)]
pub enum DescribeCacheParameterGroupsError {
CacheParameterGroupNotFoundFault(String),
InvalidParameterCombination(String),
InvalidParameterValue(String),
}
impl DescribeCacheParameterGroupsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeCacheParameterGroupsError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"CacheParameterGroupNotFound" => {
return RusotoError::Service(
DescribeCacheParameterGroupsError::CacheParameterGroupNotFoundFault(
parsed_error.message,
),
)
}
"InvalidParameterCombination" => {
return RusotoError::Service(
DescribeCacheParameterGroupsError::InvalidParameterCombination(
parsed_error.message,
),
)
}
"InvalidParameterValue" => {
return RusotoError::Service(
DescribeCacheParameterGroupsError::InvalidParameterValue(
parsed_error.message,
),
)
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeCacheParameterGroupsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeCacheParameterGroupsError::CacheParameterGroupNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
DescribeCacheParameterGroupsError::InvalidParameterCombination(ref cause) => {
write!(f, "{}", cause)
}
DescribeCacheParameterGroupsError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DescribeCacheParameterGroupsError {}
#[derive(Debug, PartialEq)]
pub enum DescribeCacheParametersError {
CacheParameterGroupNotFoundFault(String),
InvalidParameterCombination(String),
InvalidParameterValue(String),
}
impl DescribeCacheParametersError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeCacheParametersError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"CacheParameterGroupNotFound" => {
return RusotoError::Service(
DescribeCacheParametersError::CacheParameterGroupNotFoundFault(
parsed_error.message,
),
)
}
"InvalidParameterCombination" => {
return RusotoError::Service(
DescribeCacheParametersError::InvalidParameterCombination(
parsed_error.message,
),
)
}
"InvalidParameterValue" => {
return RusotoError::Service(
DescribeCacheParametersError::InvalidParameterValue(
parsed_error.message,
),
)
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeCacheParametersError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeCacheParametersError::CacheParameterGroupNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
DescribeCacheParametersError::InvalidParameterCombination(ref cause) => {
write!(f, "{}", cause)
}
DescribeCacheParametersError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DescribeCacheParametersError {}
#[derive(Debug, PartialEq)]
pub enum DescribeCacheSecurityGroupsError {
CacheSecurityGroupNotFoundFault(String),
InvalidParameterCombination(String),
InvalidParameterValue(String),
}
impl DescribeCacheSecurityGroupsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeCacheSecurityGroupsError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"CacheSecurityGroupNotFound" => {
return RusotoError::Service(
DescribeCacheSecurityGroupsError::CacheSecurityGroupNotFoundFault(
parsed_error.message,
),
)
}
"InvalidParameterCombination" => {
return RusotoError::Service(
DescribeCacheSecurityGroupsError::InvalidParameterCombination(
parsed_error.message,
),
)
}
"InvalidParameterValue" => {
return RusotoError::Service(
DescribeCacheSecurityGroupsError::InvalidParameterValue(
parsed_error.message,
),
)
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeCacheSecurityGroupsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeCacheSecurityGroupsError::CacheSecurityGroupNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
DescribeCacheSecurityGroupsError::InvalidParameterCombination(ref cause) => {
write!(f, "{}", cause)
}
DescribeCacheSecurityGroupsError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DescribeCacheSecurityGroupsError {}
#[derive(Debug, PartialEq)]
pub enum DescribeCacheSubnetGroupsError {
CacheSubnetGroupNotFoundFault(String),
}
impl DescribeCacheSubnetGroupsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeCacheSubnetGroupsError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"CacheSubnetGroupNotFoundFault" => {
return RusotoError::Service(
DescribeCacheSubnetGroupsError::CacheSubnetGroupNotFoundFault(
parsed_error.message,
),
)
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeCacheSubnetGroupsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeCacheSubnetGroupsError::CacheSubnetGroupNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DescribeCacheSubnetGroupsError {}
#[derive(Debug, PartialEq)]
pub enum DescribeEngineDefaultParametersError {
InvalidParameterCombination(String),
InvalidParameterValue(String),
}
impl DescribeEngineDefaultParametersError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeEngineDefaultParametersError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"InvalidParameterCombination" => {
return RusotoError::Service(
DescribeEngineDefaultParametersError::InvalidParameterCombination(
parsed_error.message,
),
)
}
"InvalidParameterValue" => {
return RusotoError::Service(
DescribeEngineDefaultParametersError::InvalidParameterValue(
parsed_error.message,
),
)
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeEngineDefaultParametersError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeEngineDefaultParametersError::InvalidParameterCombination(ref cause) => {
write!(f, "{}", cause)
}
DescribeEngineDefaultParametersError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DescribeEngineDefaultParametersError {}
#[derive(Debug, PartialEq)]
pub enum DescribeEventsError {
InvalidParameterCombination(String),
InvalidParameterValue(String),
}
impl DescribeEventsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeEventsError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"InvalidParameterCombination" => {
return RusotoError::Service(
DescribeEventsError::InvalidParameterCombination(parsed_error.message),
)
}
"InvalidParameterValue" => {
return RusotoError::Service(DescribeEventsError::InvalidParameterValue(
parsed_error.message,
))
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeEventsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeEventsError::InvalidParameterCombination(ref cause) => write!(f, "{}", cause),
DescribeEventsError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeEventsError {}
#[derive(Debug, PartialEq)]
pub enum DescribeGlobalReplicationGroupsError {
GlobalReplicationGroupNotFoundFault(String),
InvalidParameterCombination(String),
InvalidParameterValue(String),
}
impl DescribeGlobalReplicationGroupsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeGlobalReplicationGroupsError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"GlobalReplicationGroupNotFoundFault" => return RusotoError::Service(
DescribeGlobalReplicationGroupsError::GlobalReplicationGroupNotFoundFault(
parsed_error.message,
),
),
"InvalidParameterCombination" => {
return RusotoError::Service(
DescribeGlobalReplicationGroupsError::InvalidParameterCombination(
parsed_error.message,
),
)
}
"InvalidParameterValue" => {
return RusotoError::Service(
DescribeGlobalReplicationGroupsError::InvalidParameterValue(
parsed_error.message,
),
)
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeGlobalReplicationGroupsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeGlobalReplicationGroupsError::GlobalReplicationGroupNotFoundFault(
ref cause,
) => write!(f, "{}", cause),
DescribeGlobalReplicationGroupsError::InvalidParameterCombination(ref cause) => {
write!(f, "{}", cause)
}
DescribeGlobalReplicationGroupsError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DescribeGlobalReplicationGroupsError {}
#[derive(Debug, PartialEq)]
pub enum DescribeReplicationGroupsError {
InvalidParameterCombination(String),
InvalidParameterValue(String),
ReplicationGroupNotFoundFault(String),
}
impl DescribeReplicationGroupsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeReplicationGroupsError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"InvalidParameterCombination" => {
return RusotoError::Service(
DescribeReplicationGroupsError::InvalidParameterCombination(
parsed_error.message,
),
)
}
"InvalidParameterValue" => {
return RusotoError::Service(
DescribeReplicationGroupsError::InvalidParameterValue(
parsed_error.message,
),
)
}
"ReplicationGroupNotFoundFault" => {
return RusotoError::Service(
DescribeReplicationGroupsError::ReplicationGroupNotFoundFault(
parsed_error.message,
),
)
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeReplicationGroupsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeReplicationGroupsError::InvalidParameterCombination(ref cause) => {
write!(f, "{}", cause)
}
DescribeReplicationGroupsError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
DescribeReplicationGroupsError::ReplicationGroupNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DescribeReplicationGroupsError {}
#[derive(Debug, PartialEq)]
pub enum DescribeReservedCacheNodesError {
InvalidParameterCombination(String),
InvalidParameterValue(String),
ReservedCacheNodeNotFoundFault(String),
}
impl DescribeReservedCacheNodesError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeReservedCacheNodesError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"InvalidParameterCombination" => {
return RusotoError::Service(
DescribeReservedCacheNodesError::InvalidParameterCombination(
parsed_error.message,
),
)
}
"InvalidParameterValue" => {
return RusotoError::Service(
DescribeReservedCacheNodesError::InvalidParameterValue(
parsed_error.message,
),
)
}
"ReservedCacheNodeNotFound" => {
return RusotoError::Service(
DescribeReservedCacheNodesError::ReservedCacheNodeNotFoundFault(
parsed_error.message,
),
)
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeReservedCacheNodesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeReservedCacheNodesError::InvalidParameterCombination(ref cause) => {
write!(f, "{}", cause)
}
DescribeReservedCacheNodesError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
DescribeReservedCacheNodesError::ReservedCacheNodeNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DescribeReservedCacheNodesError {}
#[derive(Debug, PartialEq)]
pub enum DescribeReservedCacheNodesOfferingsError {
InvalidParameterCombination(String),
InvalidParameterValue(String),
ReservedCacheNodesOfferingNotFoundFault(String),
}
impl DescribeReservedCacheNodesOfferingsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeReservedCacheNodesOfferingsError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"InvalidParameterCombination" => return RusotoError::Service(DescribeReservedCacheNodesOfferingsError::InvalidParameterCombination(parsed_error.message)),"InvalidParameterValue" => return RusotoError::Service(DescribeReservedCacheNodesOfferingsError::InvalidParameterValue(parsed_error.message)),"ReservedCacheNodesOfferingNotFound" => return RusotoError::Service(DescribeReservedCacheNodesOfferingsError::ReservedCacheNodesOfferingNotFoundFault(parsed_error.message)),_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeReservedCacheNodesOfferingsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeReservedCacheNodesOfferingsError::InvalidParameterCombination(ref cause) => {
write!(f, "{}", cause)
}
DescribeReservedCacheNodesOfferingsError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
DescribeReservedCacheNodesOfferingsError::ReservedCacheNodesOfferingNotFoundFault(
ref cause,
) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeReservedCacheNodesOfferingsError {}
#[derive(Debug, PartialEq)]
pub enum DescribeServiceUpdatesError {
InvalidParameterCombination(String),
InvalidParameterValue(String),
ServiceUpdateNotFoundFault(String),
}
impl DescribeServiceUpdatesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeServiceUpdatesError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"InvalidParameterCombination" => {
return RusotoError::Service(
DescribeServiceUpdatesError::InvalidParameterCombination(
parsed_error.message,
),
)
}
"InvalidParameterValue" => {
return RusotoError::Service(
DescribeServiceUpdatesError::InvalidParameterValue(
parsed_error.message,
),
)
}
"ServiceUpdateNotFoundFault" => {
return RusotoError::Service(
DescribeServiceUpdatesError::ServiceUpdateNotFoundFault(
parsed_error.message,
),
)
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeServiceUpdatesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeServiceUpdatesError::InvalidParameterCombination(ref cause) => {
write!(f, "{}", cause)
}
DescribeServiceUpdatesError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
DescribeServiceUpdatesError::ServiceUpdateNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DescribeServiceUpdatesError {}
#[derive(Debug, PartialEq)]
pub enum DescribeSnapshotsError {
CacheClusterNotFoundFault(String),
InvalidParameterCombination(String),
InvalidParameterValue(String),
SnapshotNotFoundFault(String),
}
impl DescribeSnapshotsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeSnapshotsError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"CacheClusterNotFound" => {
return RusotoError::Service(
DescribeSnapshotsError::CacheClusterNotFoundFault(parsed_error.message),
)
}
"InvalidParameterCombination" => {
return RusotoError::Service(
DescribeSnapshotsError::InvalidParameterCombination(
parsed_error.message,
),
)
}
"InvalidParameterValue" => {
return RusotoError::Service(DescribeSnapshotsError::InvalidParameterValue(
parsed_error.message,
))
}
"SnapshotNotFoundFault" => {
return RusotoError::Service(DescribeSnapshotsError::SnapshotNotFoundFault(
parsed_error.message,
))
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeSnapshotsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeSnapshotsError::CacheClusterNotFoundFault(ref cause) => write!(f, "{}", cause),
DescribeSnapshotsError::InvalidParameterCombination(ref cause) => {
write!(f, "{}", cause)
}
DescribeSnapshotsError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
DescribeSnapshotsError::SnapshotNotFoundFault(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeSnapshotsError {}
#[derive(Debug, PartialEq)]
pub enum DescribeUpdateActionsError {
InvalidParameterCombination(String),
InvalidParameterValue(String),
}
impl DescribeUpdateActionsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeUpdateActionsError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"InvalidParameterCombination" => {
return RusotoError::Service(
DescribeUpdateActionsError::InvalidParameterCombination(
parsed_error.message,
),
)
}
"InvalidParameterValue" => {
return RusotoError::Service(
DescribeUpdateActionsError::InvalidParameterValue(parsed_error.message),
)
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DescribeUpdateActionsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeUpdateActionsError::InvalidParameterCombination(ref cause) => {
write!(f, "{}", cause)
}
DescribeUpdateActionsError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeUpdateActionsError {}
#[derive(Debug, PartialEq)]
pub enum DisassociateGlobalReplicationGroupError {
GlobalReplicationGroupNotFoundFault(String),
InvalidGlobalReplicationGroupStateFault(String),
InvalidParameterCombination(String),
InvalidParameterValue(String),
}
impl DisassociateGlobalReplicationGroupError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DisassociateGlobalReplicationGroupError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"GlobalReplicationGroupNotFoundFault" => return RusotoError::Service(DisassociateGlobalReplicationGroupError::GlobalReplicationGroupNotFoundFault(parsed_error.message)),"InvalidGlobalReplicationGroupState" => return RusotoError::Service(DisassociateGlobalReplicationGroupError::InvalidGlobalReplicationGroupStateFault(parsed_error.message)),"InvalidParameterCombination" => return RusotoError::Service(DisassociateGlobalReplicationGroupError::InvalidParameterCombination(parsed_error.message)),"InvalidParameterValue" => return RusotoError::Service(DisassociateGlobalReplicationGroupError::InvalidParameterValue(parsed_error.message)),_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for DisassociateGlobalReplicationGroupError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DisassociateGlobalReplicationGroupError::GlobalReplicationGroupNotFoundFault(
ref cause,
) => write!(f, "{}", cause),
DisassociateGlobalReplicationGroupError::InvalidGlobalReplicationGroupStateFault(
ref cause,
) => write!(f, "{}", cause),
DisassociateGlobalReplicationGroupError::InvalidParameterCombination(ref cause) => {
write!(f, "{}", cause)
}
DisassociateGlobalReplicationGroupError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DisassociateGlobalReplicationGroupError {}
#[derive(Debug, PartialEq)]
pub enum FailoverGlobalReplicationGroupError {
GlobalReplicationGroupNotFoundFault(String),
InvalidGlobalReplicationGroupStateFault(String),
InvalidParameterCombination(String),
InvalidParameterValue(String),
}
impl FailoverGlobalReplicationGroupError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<FailoverGlobalReplicationGroupError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"GlobalReplicationGroupNotFoundFault" => return RusotoError::Service(FailoverGlobalReplicationGroupError::GlobalReplicationGroupNotFoundFault(parsed_error.message)),"InvalidGlobalReplicationGroupState" => return RusotoError::Service(FailoverGlobalReplicationGroupError::InvalidGlobalReplicationGroupStateFault(parsed_error.message)),"InvalidParameterCombination" => return RusotoError::Service(FailoverGlobalReplicationGroupError::InvalidParameterCombination(parsed_error.message)),"InvalidParameterValue" => return RusotoError::Service(FailoverGlobalReplicationGroupError::InvalidParameterValue(parsed_error.message)),_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for FailoverGlobalReplicationGroupError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
FailoverGlobalReplicationGroupError::GlobalReplicationGroupNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
FailoverGlobalReplicationGroupError::InvalidGlobalReplicationGroupStateFault(
ref cause,
) => write!(f, "{}", cause),
FailoverGlobalReplicationGroupError::InvalidParameterCombination(ref cause) => {
write!(f, "{}", cause)
}
FailoverGlobalReplicationGroupError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for FailoverGlobalReplicationGroupError {}
#[derive(Debug, PartialEq)]
pub enum IncreaseNodeGroupsInGlobalReplicationGroupError {
GlobalReplicationGroupNotFoundFault(String),
InvalidGlobalReplicationGroupStateFault(String),
InvalidParameterValue(String),
}
impl IncreaseNodeGroupsInGlobalReplicationGroupError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<IncreaseNodeGroupsInGlobalReplicationGroupError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"GlobalReplicationGroupNotFoundFault" => return RusotoError::Service(IncreaseNodeGroupsInGlobalReplicationGroupError::GlobalReplicationGroupNotFoundFault(parsed_error.message)),"InvalidGlobalReplicationGroupState" => return RusotoError::Service(IncreaseNodeGroupsInGlobalReplicationGroupError::InvalidGlobalReplicationGroupStateFault(parsed_error.message)),"InvalidParameterValue" => return RusotoError::Service(IncreaseNodeGroupsInGlobalReplicationGroupError::InvalidParameterValue(parsed_error.message)),_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for IncreaseNodeGroupsInGlobalReplicationGroupError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
IncreaseNodeGroupsInGlobalReplicationGroupError::GlobalReplicationGroupNotFoundFault(ref cause) => write!(f, "{}", cause),
IncreaseNodeGroupsInGlobalReplicationGroupError::InvalidGlobalReplicationGroupStateFault(ref cause) => write!(f, "{}", cause),
IncreaseNodeGroupsInGlobalReplicationGroupError::InvalidParameterValue(ref cause) => write!(f, "{}", cause)
}
}
}
impl Error for IncreaseNodeGroupsInGlobalReplicationGroupError {}
#[derive(Debug, PartialEq)]
pub enum IncreaseReplicaCountError {
ClusterQuotaForCustomerExceededFault(String),
InsufficientCacheClusterCapacityFault(String),
InvalidCacheClusterStateFault(String),
InvalidKMSKeyFault(String),
InvalidParameterCombination(String),
InvalidParameterValue(String),
InvalidReplicationGroupStateFault(String),
InvalidVPCNetworkStateFault(String),
NoOperationFault(String),
NodeGroupsPerReplicationGroupQuotaExceededFault(String),
NodeQuotaForCustomerExceededFault(String),
ReplicationGroupNotFoundFault(String),
}
impl IncreaseReplicaCountError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<IncreaseReplicaCountError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"ClusterQuotaForCustomerExceeded" => {
return RusotoError::Service(
IncreaseReplicaCountError::ClusterQuotaForCustomerExceededFault(
parsed_error.message,
),
)
}
"InsufficientCacheClusterCapacity" => {
return RusotoError::Service(
IncreaseReplicaCountError::InsufficientCacheClusterCapacityFault(
parsed_error.message,
),
)
}
"InvalidCacheClusterState" => {
return RusotoError::Service(
IncreaseReplicaCountError::InvalidCacheClusterStateFault(
parsed_error.message,
),
)
}
"InvalidKMSKeyFault" => {
return RusotoError::Service(IncreaseReplicaCountError::InvalidKMSKeyFault(
parsed_error.message,
))
}
"InvalidParameterCombination" => {
return RusotoError::Service(
IncreaseReplicaCountError::InvalidParameterCombination(
parsed_error.message,
),
)
}
"InvalidParameterValue" => {
return RusotoError::Service(
IncreaseReplicaCountError::InvalidParameterValue(parsed_error.message),
)
}
"InvalidReplicationGroupState" => {
return RusotoError::Service(
IncreaseReplicaCountError::InvalidReplicationGroupStateFault(
parsed_error.message,
),
)
}
"InvalidVPCNetworkStateFault" => {
return RusotoError::Service(
IncreaseReplicaCountError::InvalidVPCNetworkStateFault(
parsed_error.message,
),
)
}
"NoOperationFault" => {
return RusotoError::Service(IncreaseReplicaCountError::NoOperationFault(
parsed_error.message,
))
}
"NodeGroupsPerReplicationGroupQuotaExceeded" => return RusotoError::Service(
IncreaseReplicaCountError::NodeGroupsPerReplicationGroupQuotaExceededFault(
parsed_error.message,
),
),
"NodeQuotaForCustomerExceeded" => {
return RusotoError::Service(
IncreaseReplicaCountError::NodeQuotaForCustomerExceededFault(
parsed_error.message,
),
)
}
"ReplicationGroupNotFoundFault" => {
return RusotoError::Service(
IncreaseReplicaCountError::ReplicationGroupNotFoundFault(
parsed_error.message,
),
)
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for IncreaseReplicaCountError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
IncreaseReplicaCountError::ClusterQuotaForCustomerExceededFault(ref cause) => {
write!(f, "{}", cause)
}
IncreaseReplicaCountError::InsufficientCacheClusterCapacityFault(ref cause) => {
write!(f, "{}", cause)
}
IncreaseReplicaCountError::InvalidCacheClusterStateFault(ref cause) => {
write!(f, "{}", cause)
}
IncreaseReplicaCountError::InvalidKMSKeyFault(ref cause) => write!(f, "{}", cause),
IncreaseReplicaCountError::InvalidParameterCombination(ref cause) => {
write!(f, "{}", cause)
}
IncreaseReplicaCountError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
IncreaseReplicaCountError::InvalidReplicationGroupStateFault(ref cause) => {
write!(f, "{}", cause)
}
IncreaseReplicaCountError::InvalidVPCNetworkStateFault(ref cause) => {
write!(f, "{}", cause)
}
IncreaseReplicaCountError::NoOperationFault(ref cause) => write!(f, "{}", cause),
IncreaseReplicaCountError::NodeGroupsPerReplicationGroupQuotaExceededFault(
ref cause,
) => write!(f, "{}", cause),
IncreaseReplicaCountError::NodeQuotaForCustomerExceededFault(ref cause) => {
write!(f, "{}", cause)
}
IncreaseReplicaCountError::ReplicationGroupNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for IncreaseReplicaCountError {}
#[derive(Debug, PartialEq)]
pub enum ListAllowedNodeTypeModificationsError {
CacheClusterNotFoundFault(String),
InvalidParameterCombination(String),
InvalidParameterValue(String),
ReplicationGroupNotFoundFault(String),
}
impl ListAllowedNodeTypeModificationsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ListAllowedNodeTypeModificationsError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"CacheClusterNotFound" => {
return RusotoError::Service(
ListAllowedNodeTypeModificationsError::CacheClusterNotFoundFault(
parsed_error.message,
),
)
}
"InvalidParameterCombination" => {
return RusotoError::Service(
ListAllowedNodeTypeModificationsError::InvalidParameterCombination(
parsed_error.message,
),
)
}
"InvalidParameterValue" => {
return RusotoError::Service(
ListAllowedNodeTypeModificationsError::InvalidParameterValue(
parsed_error.message,
),
)
}
"ReplicationGroupNotFoundFault" => {
return RusotoError::Service(
ListAllowedNodeTypeModificationsError::ReplicationGroupNotFoundFault(
parsed_error.message,
),
)
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for ListAllowedNodeTypeModificationsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListAllowedNodeTypeModificationsError::CacheClusterNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
ListAllowedNodeTypeModificationsError::InvalidParameterCombination(ref cause) => {
write!(f, "{}", cause)
}
ListAllowedNodeTypeModificationsError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
ListAllowedNodeTypeModificationsError::ReplicationGroupNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for ListAllowedNodeTypeModificationsError {}
#[derive(Debug, PartialEq)]
pub enum ListTagsForResourceError {
CacheClusterNotFoundFault(String),
InvalidARNFault(String),
SnapshotNotFoundFault(String),
}
impl ListTagsForResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListTagsForResourceError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"CacheClusterNotFound" => {
return RusotoError::Service(
ListTagsForResourceError::CacheClusterNotFoundFault(
parsed_error.message,
),
)
}
"InvalidARN" => {
return RusotoError::Service(ListTagsForResourceError::InvalidARNFault(
parsed_error.message,
))
}
"SnapshotNotFoundFault" => {
return RusotoError::Service(
ListTagsForResourceError::SnapshotNotFoundFault(parsed_error.message),
)
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for ListTagsForResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListTagsForResourceError::CacheClusterNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
ListTagsForResourceError::InvalidARNFault(ref cause) => write!(f, "{}", cause),
ListTagsForResourceError::SnapshotNotFoundFault(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListTagsForResourceError {}
#[derive(Debug, PartialEq)]
pub enum ModifyCacheClusterError {
CacheClusterNotFoundFault(String),
CacheParameterGroupNotFoundFault(String),
CacheSecurityGroupNotFoundFault(String),
InsufficientCacheClusterCapacityFault(String),
InvalidCacheClusterStateFault(String),
InvalidCacheSecurityGroupStateFault(String),
InvalidParameterCombination(String),
InvalidParameterValue(String),
InvalidVPCNetworkStateFault(String),
NodeQuotaForClusterExceededFault(String),
NodeQuotaForCustomerExceededFault(String),
}
impl ModifyCacheClusterError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ModifyCacheClusterError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"CacheClusterNotFound" => {
return RusotoError::Service(
ModifyCacheClusterError::CacheClusterNotFoundFault(
parsed_error.message,
),
)
}
"CacheParameterGroupNotFound" => {
return RusotoError::Service(
ModifyCacheClusterError::CacheParameterGroupNotFoundFault(
parsed_error.message,
),
)
}
"CacheSecurityGroupNotFound" => {
return RusotoError::Service(
ModifyCacheClusterError::CacheSecurityGroupNotFoundFault(
parsed_error.message,
),
)
}
"InsufficientCacheClusterCapacity" => {
return RusotoError::Service(
ModifyCacheClusterError::InsufficientCacheClusterCapacityFault(
parsed_error.message,
),
)
}
"InvalidCacheClusterState" => {
return RusotoError::Service(
ModifyCacheClusterError::InvalidCacheClusterStateFault(
parsed_error.message,
),
)
}
"InvalidCacheSecurityGroupState" => {
return RusotoError::Service(
ModifyCacheClusterError::InvalidCacheSecurityGroupStateFault(
parsed_error.message,
),
)
}
"InvalidParameterCombination" => {
return RusotoError::Service(
ModifyCacheClusterError::InvalidParameterCombination(
parsed_error.message,
),
)
}
"InvalidParameterValue" => {
return RusotoError::Service(
ModifyCacheClusterError::InvalidParameterValue(parsed_error.message),
)
}
"InvalidVPCNetworkStateFault" => {
return RusotoError::Service(
ModifyCacheClusterError::InvalidVPCNetworkStateFault(
parsed_error.message,
),
)
}
"NodeQuotaForClusterExceeded" => {
return RusotoError::Service(
ModifyCacheClusterError::NodeQuotaForClusterExceededFault(
parsed_error.message,
),
)
}
"NodeQuotaForCustomerExceeded" => {
return RusotoError::Service(
ModifyCacheClusterError::NodeQuotaForCustomerExceededFault(
parsed_error.message,
),
)
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for ModifyCacheClusterError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ModifyCacheClusterError::CacheClusterNotFoundFault(ref cause) => write!(f, "{}", cause),
ModifyCacheClusterError::CacheParameterGroupNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
ModifyCacheClusterError::CacheSecurityGroupNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
ModifyCacheClusterError::InsufficientCacheClusterCapacityFault(ref cause) => {
write!(f, "{}", cause)
}
ModifyCacheClusterError::InvalidCacheClusterStateFault(ref cause) => {
write!(f, "{}", cause)
}
ModifyCacheClusterError::InvalidCacheSecurityGroupStateFault(ref cause) => {
write!(f, "{}", cause)
}
ModifyCacheClusterError::InvalidParameterCombination(ref cause) => {
write!(f, "{}", cause)
}
ModifyCacheClusterError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
ModifyCacheClusterError::InvalidVPCNetworkStateFault(ref cause) => {
write!(f, "{}", cause)
}
ModifyCacheClusterError::NodeQuotaForClusterExceededFault(ref cause) => {
write!(f, "{}", cause)
}
ModifyCacheClusterError::NodeQuotaForCustomerExceededFault(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for ModifyCacheClusterError {}
#[derive(Debug, PartialEq)]
pub enum ModifyCacheParameterGroupError {
CacheParameterGroupNotFoundFault(String),
InvalidCacheParameterGroupStateFault(String),
InvalidGlobalReplicationGroupStateFault(String),
InvalidParameterCombination(String),
InvalidParameterValue(String),
}
impl ModifyCacheParameterGroupError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ModifyCacheParameterGroupError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"CacheParameterGroupNotFound" => {
return RusotoError::Service(
ModifyCacheParameterGroupError::CacheParameterGroupNotFoundFault(
parsed_error.message,
),
)
}
"InvalidCacheParameterGroupState" => {
return RusotoError::Service(
ModifyCacheParameterGroupError::InvalidCacheParameterGroupStateFault(
parsed_error.message,
),
)
}
"InvalidGlobalReplicationGroupState" => {
return RusotoError::Service(
ModifyCacheParameterGroupError::InvalidGlobalReplicationGroupStateFault(
parsed_error.message,
),
)
}
"InvalidParameterCombination" => {
return RusotoError::Service(
ModifyCacheParameterGroupError::InvalidParameterCombination(
parsed_error.message,
),
)
}
"InvalidParameterValue" => {
return RusotoError::Service(
ModifyCacheParameterGroupError::InvalidParameterValue(
parsed_error.message,
),
)
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for ModifyCacheParameterGroupError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ModifyCacheParameterGroupError::CacheParameterGroupNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
ModifyCacheParameterGroupError::InvalidCacheParameterGroupStateFault(ref cause) => {
write!(f, "{}", cause)
}
ModifyCacheParameterGroupError::InvalidGlobalReplicationGroupStateFault(ref cause) => {
write!(f, "{}", cause)
}
ModifyCacheParameterGroupError::InvalidParameterCombination(ref cause) => {
write!(f, "{}", cause)
}
ModifyCacheParameterGroupError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for ModifyCacheParameterGroupError {}
#[derive(Debug, PartialEq)]
pub enum ModifyCacheSubnetGroupError {
CacheSubnetGroupNotFoundFault(String),
CacheSubnetQuotaExceededFault(String),
InvalidSubnet(String),
SubnetInUse(String),
}
impl ModifyCacheSubnetGroupError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ModifyCacheSubnetGroupError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"CacheSubnetGroupNotFoundFault" => {
return RusotoError::Service(
ModifyCacheSubnetGroupError::CacheSubnetGroupNotFoundFault(
parsed_error.message,
),
)
}
"CacheSubnetQuotaExceededFault" => {
return RusotoError::Service(
ModifyCacheSubnetGroupError::CacheSubnetQuotaExceededFault(
parsed_error.message,
),
)
}
"InvalidSubnet" => {
return RusotoError::Service(ModifyCacheSubnetGroupError::InvalidSubnet(
parsed_error.message,
))
}
"SubnetInUse" => {
return RusotoError::Service(ModifyCacheSubnetGroupError::SubnetInUse(
parsed_error.message,
))
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for ModifyCacheSubnetGroupError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ModifyCacheSubnetGroupError::CacheSubnetGroupNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
ModifyCacheSubnetGroupError::CacheSubnetQuotaExceededFault(ref cause) => {
write!(f, "{}", cause)
}
ModifyCacheSubnetGroupError::InvalidSubnet(ref cause) => write!(f, "{}", cause),
ModifyCacheSubnetGroupError::SubnetInUse(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ModifyCacheSubnetGroupError {}
#[derive(Debug, PartialEq)]
pub enum ModifyGlobalReplicationGroupError {
GlobalReplicationGroupNotFoundFault(String),
InvalidGlobalReplicationGroupStateFault(String),
InvalidParameterValue(String),
}
impl ModifyGlobalReplicationGroupError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ModifyGlobalReplicationGroupError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"GlobalReplicationGroupNotFoundFault" => {
return RusotoError::Service(
ModifyGlobalReplicationGroupError::GlobalReplicationGroupNotFoundFault(
parsed_error.message,
),
)
}
"InvalidGlobalReplicationGroupState" => return RusotoError::Service(
ModifyGlobalReplicationGroupError::InvalidGlobalReplicationGroupStateFault(
parsed_error.message,
),
),
"InvalidParameterValue" => {
return RusotoError::Service(
ModifyGlobalReplicationGroupError::InvalidParameterValue(
parsed_error.message,
),
)
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for ModifyGlobalReplicationGroupError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ModifyGlobalReplicationGroupError::GlobalReplicationGroupNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
ModifyGlobalReplicationGroupError::InvalidGlobalReplicationGroupStateFault(
ref cause,
) => write!(f, "{}", cause),
ModifyGlobalReplicationGroupError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for ModifyGlobalReplicationGroupError {}
#[derive(Debug, PartialEq)]
pub enum ModifyReplicationGroupError {
CacheClusterNotFoundFault(String),
CacheParameterGroupNotFoundFault(String),
CacheSecurityGroupNotFoundFault(String),
InsufficientCacheClusterCapacityFault(String),
InvalidCacheClusterStateFault(String),
InvalidCacheSecurityGroupStateFault(String),
InvalidKMSKeyFault(String),
InvalidParameterCombination(String),
InvalidParameterValue(String),
InvalidReplicationGroupStateFault(String),
InvalidVPCNetworkStateFault(String),
NodeQuotaForClusterExceededFault(String),
NodeQuotaForCustomerExceededFault(String),
ReplicationGroupNotFoundFault(String),
}
impl ModifyReplicationGroupError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ModifyReplicationGroupError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"CacheClusterNotFound" => {
return RusotoError::Service(
ModifyReplicationGroupError::CacheClusterNotFoundFault(
parsed_error.message,
),
)
}
"CacheParameterGroupNotFound" => {
return RusotoError::Service(
ModifyReplicationGroupError::CacheParameterGroupNotFoundFault(
parsed_error.message,
),
)
}
"CacheSecurityGroupNotFound" => {
return RusotoError::Service(
ModifyReplicationGroupError::CacheSecurityGroupNotFoundFault(
parsed_error.message,
),
)
}
"InsufficientCacheClusterCapacity" => {
return RusotoError::Service(
ModifyReplicationGroupError::InsufficientCacheClusterCapacityFault(
parsed_error.message,
),
)
}
"InvalidCacheClusterState" => {
return RusotoError::Service(
ModifyReplicationGroupError::InvalidCacheClusterStateFault(
parsed_error.message,
),
)
}
"InvalidCacheSecurityGroupState" => {
return RusotoError::Service(
ModifyReplicationGroupError::InvalidCacheSecurityGroupStateFault(
parsed_error.message,
),
)
}
"InvalidKMSKeyFault" => {
return RusotoError::Service(
ModifyReplicationGroupError::InvalidKMSKeyFault(parsed_error.message),
)
}
"InvalidParameterCombination" => {
return RusotoError::Service(
ModifyReplicationGroupError::InvalidParameterCombination(
parsed_error.message,
),
)
}
"InvalidParameterValue" => {
return RusotoError::Service(
ModifyReplicationGroupError::InvalidParameterValue(
parsed_error.message,
),
)
}
"InvalidReplicationGroupState" => {
return RusotoError::Service(
ModifyReplicationGroupError::InvalidReplicationGroupStateFault(
parsed_error.message,
),
)
}
"InvalidVPCNetworkStateFault" => {
return RusotoError::Service(
ModifyReplicationGroupError::InvalidVPCNetworkStateFault(
parsed_error.message,
),
)
}
"NodeQuotaForClusterExceeded" => {
return RusotoError::Service(
ModifyReplicationGroupError::NodeQuotaForClusterExceededFault(
parsed_error.message,
),
)
}
"NodeQuotaForCustomerExceeded" => {
return RusotoError::Service(
ModifyReplicationGroupError::NodeQuotaForCustomerExceededFault(
parsed_error.message,
),
)
}
"ReplicationGroupNotFoundFault" => {
return RusotoError::Service(
ModifyReplicationGroupError::ReplicationGroupNotFoundFault(
parsed_error.message,
),
)
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for ModifyReplicationGroupError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ModifyReplicationGroupError::CacheClusterNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
ModifyReplicationGroupError::CacheParameterGroupNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
ModifyReplicationGroupError::CacheSecurityGroupNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
ModifyReplicationGroupError::InsufficientCacheClusterCapacityFault(ref cause) => {
write!(f, "{}", cause)
}
ModifyReplicationGroupError::InvalidCacheClusterStateFault(ref cause) => {
write!(f, "{}", cause)
}
ModifyReplicationGroupError::InvalidCacheSecurityGroupStateFault(ref cause) => {
write!(f, "{}", cause)
}
ModifyReplicationGroupError::InvalidKMSKeyFault(ref cause) => write!(f, "{}", cause),
ModifyReplicationGroupError::InvalidParameterCombination(ref cause) => {
write!(f, "{}", cause)
}
ModifyReplicationGroupError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
ModifyReplicationGroupError::InvalidReplicationGroupStateFault(ref cause) => {
write!(f, "{}", cause)
}
ModifyReplicationGroupError::InvalidVPCNetworkStateFault(ref cause) => {
write!(f, "{}", cause)
}
ModifyReplicationGroupError::NodeQuotaForClusterExceededFault(ref cause) => {
write!(f, "{}", cause)
}
ModifyReplicationGroupError::NodeQuotaForCustomerExceededFault(ref cause) => {
write!(f, "{}", cause)
}
ModifyReplicationGroupError::ReplicationGroupNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for ModifyReplicationGroupError {}
#[derive(Debug, PartialEq)]
pub enum ModifyReplicationGroupShardConfigurationError {
InsufficientCacheClusterCapacityFault(String),
InvalidCacheClusterStateFault(String),
InvalidKMSKeyFault(String),
InvalidParameterCombination(String),
InvalidParameterValue(String),
InvalidReplicationGroupStateFault(String),
InvalidVPCNetworkStateFault(String),
NodeGroupsPerReplicationGroupQuotaExceededFault(String),
NodeQuotaForCustomerExceededFault(String),
ReplicationGroupNotFoundFault(String),
}
impl ModifyReplicationGroupShardConfigurationError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ModifyReplicationGroupShardConfigurationError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"InsufficientCacheClusterCapacity" => return RusotoError::Service(ModifyReplicationGroupShardConfigurationError::InsufficientCacheClusterCapacityFault(parsed_error.message)),"InvalidCacheClusterState" => return RusotoError::Service(ModifyReplicationGroupShardConfigurationError::InvalidCacheClusterStateFault(parsed_error.message)),"InvalidKMSKeyFault" => return RusotoError::Service(ModifyReplicationGroupShardConfigurationError::InvalidKMSKeyFault(parsed_error.message)),"InvalidParameterCombination" => return RusotoError::Service(ModifyReplicationGroupShardConfigurationError::InvalidParameterCombination(parsed_error.message)),"InvalidParameterValue" => return RusotoError::Service(ModifyReplicationGroupShardConfigurationError::InvalidParameterValue(parsed_error.message)),"InvalidReplicationGroupState" => return RusotoError::Service(ModifyReplicationGroupShardConfigurationError::InvalidReplicationGroupStateFault(parsed_error.message)),"InvalidVPCNetworkStateFault" => return RusotoError::Service(ModifyReplicationGroupShardConfigurationError::InvalidVPCNetworkStateFault(parsed_error.message)),"NodeGroupsPerReplicationGroupQuotaExceeded" => return RusotoError::Service(ModifyReplicationGroupShardConfigurationError::NodeGroupsPerReplicationGroupQuotaExceededFault(parsed_error.message)),"NodeQuotaForCustomerExceeded" => return RusotoError::Service(ModifyReplicationGroupShardConfigurationError::NodeQuotaForCustomerExceededFault(parsed_error.message)),"ReplicationGroupNotFoundFault" => return RusotoError::Service(ModifyReplicationGroupShardConfigurationError::ReplicationGroupNotFoundFault(parsed_error.message)),_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for ModifyReplicationGroupShardConfigurationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ModifyReplicationGroupShardConfigurationError::InsufficientCacheClusterCapacityFault(ref cause) => write!(f, "{}", cause),
ModifyReplicationGroupShardConfigurationError::InvalidCacheClusterStateFault(ref cause) => write!(f, "{}", cause),
ModifyReplicationGroupShardConfigurationError::InvalidKMSKeyFault(ref cause) => write!(f, "{}", cause),
ModifyReplicationGroupShardConfigurationError::InvalidParameterCombination(ref cause) => write!(f, "{}", cause),
ModifyReplicationGroupShardConfigurationError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
ModifyReplicationGroupShardConfigurationError::InvalidReplicationGroupStateFault(ref cause) => write!(f, "{}", cause),
ModifyReplicationGroupShardConfigurationError::InvalidVPCNetworkStateFault(ref cause) => write!(f, "{}", cause),
ModifyReplicationGroupShardConfigurationError::NodeGroupsPerReplicationGroupQuotaExceededFault(ref cause) => write!(f, "{}", cause),
ModifyReplicationGroupShardConfigurationError::NodeQuotaForCustomerExceededFault(ref cause) => write!(f, "{}", cause),
ModifyReplicationGroupShardConfigurationError::ReplicationGroupNotFoundFault(ref cause) => write!(f, "{}", cause)
}
}
}
impl Error for ModifyReplicationGroupShardConfigurationError {}
#[derive(Debug, PartialEq)]
pub enum PurchaseReservedCacheNodesOfferingError {
InvalidParameterCombination(String),
InvalidParameterValue(String),
ReservedCacheNodeAlreadyExistsFault(String),
ReservedCacheNodeQuotaExceededFault(String),
ReservedCacheNodesOfferingNotFoundFault(String),
}
impl PurchaseReservedCacheNodesOfferingError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<PurchaseReservedCacheNodesOfferingError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"InvalidParameterCombination" => return RusotoError::Service(PurchaseReservedCacheNodesOfferingError::InvalidParameterCombination(parsed_error.message)),"InvalidParameterValue" => return RusotoError::Service(PurchaseReservedCacheNodesOfferingError::InvalidParameterValue(parsed_error.message)),"ReservedCacheNodeAlreadyExists" => return RusotoError::Service(PurchaseReservedCacheNodesOfferingError::ReservedCacheNodeAlreadyExistsFault(parsed_error.message)),"ReservedCacheNodeQuotaExceeded" => return RusotoError::Service(PurchaseReservedCacheNodesOfferingError::ReservedCacheNodeQuotaExceededFault(parsed_error.message)),"ReservedCacheNodesOfferingNotFound" => return RusotoError::Service(PurchaseReservedCacheNodesOfferingError::ReservedCacheNodesOfferingNotFoundFault(parsed_error.message)),_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for PurchaseReservedCacheNodesOfferingError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
PurchaseReservedCacheNodesOfferingError::InvalidParameterCombination(ref cause) => {
write!(f, "{}", cause)
}
PurchaseReservedCacheNodesOfferingError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
PurchaseReservedCacheNodesOfferingError::ReservedCacheNodeAlreadyExistsFault(
ref cause,
) => write!(f, "{}", cause),
PurchaseReservedCacheNodesOfferingError::ReservedCacheNodeQuotaExceededFault(
ref cause,
) => write!(f, "{}", cause),
PurchaseReservedCacheNodesOfferingError::ReservedCacheNodesOfferingNotFoundFault(
ref cause,
) => write!(f, "{}", cause),
}
}
}
impl Error for PurchaseReservedCacheNodesOfferingError {}
#[derive(Debug, PartialEq)]
pub enum RebalanceSlotsInGlobalReplicationGroupError {
GlobalReplicationGroupNotFoundFault(String),
InvalidGlobalReplicationGroupStateFault(String),
InvalidParameterValue(String),
}
impl RebalanceSlotsInGlobalReplicationGroupError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<RebalanceSlotsInGlobalReplicationGroupError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"GlobalReplicationGroupNotFoundFault" => return RusotoError::Service(RebalanceSlotsInGlobalReplicationGroupError::GlobalReplicationGroupNotFoundFault(parsed_error.message)),"InvalidGlobalReplicationGroupState" => return RusotoError::Service(RebalanceSlotsInGlobalReplicationGroupError::InvalidGlobalReplicationGroupStateFault(parsed_error.message)),"InvalidParameterValue" => return RusotoError::Service(RebalanceSlotsInGlobalReplicationGroupError::InvalidParameterValue(parsed_error.message)),_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for RebalanceSlotsInGlobalReplicationGroupError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
RebalanceSlotsInGlobalReplicationGroupError::GlobalReplicationGroupNotFoundFault(ref cause) => write!(f, "{}", cause),
RebalanceSlotsInGlobalReplicationGroupError::InvalidGlobalReplicationGroupStateFault(ref cause) => write!(f, "{}", cause),
RebalanceSlotsInGlobalReplicationGroupError::InvalidParameterValue(ref cause) => write!(f, "{}", cause)
}
}
}
impl Error for RebalanceSlotsInGlobalReplicationGroupError {}
#[derive(Debug, PartialEq)]
pub enum RebootCacheClusterError {
CacheClusterNotFoundFault(String),
InvalidCacheClusterStateFault(String),
}
impl RebootCacheClusterError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<RebootCacheClusterError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"CacheClusterNotFound" => {
return RusotoError::Service(
RebootCacheClusterError::CacheClusterNotFoundFault(
parsed_error.message,
),
)
}
"InvalidCacheClusterState" => {
return RusotoError::Service(
RebootCacheClusterError::InvalidCacheClusterStateFault(
parsed_error.message,
),
)
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for RebootCacheClusterError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
RebootCacheClusterError::CacheClusterNotFoundFault(ref cause) => write!(f, "{}", cause),
RebootCacheClusterError::InvalidCacheClusterStateFault(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for RebootCacheClusterError {}
#[derive(Debug, PartialEq)]
pub enum RemoveTagsFromResourceError {
CacheClusterNotFoundFault(String),
InvalidARNFault(String),
SnapshotNotFoundFault(String),
TagNotFoundFault(String),
}
impl RemoveTagsFromResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<RemoveTagsFromResourceError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"CacheClusterNotFound" => {
return RusotoError::Service(
RemoveTagsFromResourceError::CacheClusterNotFoundFault(
parsed_error.message,
),
)
}
"InvalidARN" => {
return RusotoError::Service(RemoveTagsFromResourceError::InvalidARNFault(
parsed_error.message,
))
}
"SnapshotNotFoundFault" => {
return RusotoError::Service(
RemoveTagsFromResourceError::SnapshotNotFoundFault(
parsed_error.message,
),
)
}
"TagNotFound" => {
return RusotoError::Service(RemoveTagsFromResourceError::TagNotFoundFault(
parsed_error.message,
))
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for RemoveTagsFromResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
RemoveTagsFromResourceError::CacheClusterNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
RemoveTagsFromResourceError::InvalidARNFault(ref cause) => write!(f, "{}", cause),
RemoveTagsFromResourceError::SnapshotNotFoundFault(ref cause) => write!(f, "{}", cause),
RemoveTagsFromResourceError::TagNotFoundFault(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for RemoveTagsFromResourceError {}
#[derive(Debug, PartialEq)]
pub enum ResetCacheParameterGroupError {
CacheParameterGroupNotFoundFault(String),
InvalidCacheParameterGroupStateFault(String),
InvalidGlobalReplicationGroupStateFault(String),
InvalidParameterCombination(String),
InvalidParameterValue(String),
}
impl ResetCacheParameterGroupError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ResetCacheParameterGroupError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"CacheParameterGroupNotFound" => {
return RusotoError::Service(
ResetCacheParameterGroupError::CacheParameterGroupNotFoundFault(
parsed_error.message,
),
)
}
"InvalidCacheParameterGroupState" => {
return RusotoError::Service(
ResetCacheParameterGroupError::InvalidCacheParameterGroupStateFault(
parsed_error.message,
),
)
}
"InvalidGlobalReplicationGroupState" => {
return RusotoError::Service(
ResetCacheParameterGroupError::InvalidGlobalReplicationGroupStateFault(
parsed_error.message,
),
)
}
"InvalidParameterCombination" => {
return RusotoError::Service(
ResetCacheParameterGroupError::InvalidParameterCombination(
parsed_error.message,
),
)
}
"InvalidParameterValue" => {
return RusotoError::Service(
ResetCacheParameterGroupError::InvalidParameterValue(
parsed_error.message,
),
)
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for ResetCacheParameterGroupError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ResetCacheParameterGroupError::CacheParameterGroupNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
ResetCacheParameterGroupError::InvalidCacheParameterGroupStateFault(ref cause) => {
write!(f, "{}", cause)
}
ResetCacheParameterGroupError::InvalidGlobalReplicationGroupStateFault(ref cause) => {
write!(f, "{}", cause)
}
ResetCacheParameterGroupError::InvalidParameterCombination(ref cause) => {
write!(f, "{}", cause)
}
ResetCacheParameterGroupError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for ResetCacheParameterGroupError {}
#[derive(Debug, PartialEq)]
pub enum RevokeCacheSecurityGroupIngressError {
AuthorizationNotFoundFault(String),
CacheSecurityGroupNotFoundFault(String),
InvalidCacheSecurityGroupStateFault(String),
InvalidParameterCombination(String),
InvalidParameterValue(String),
}
impl RevokeCacheSecurityGroupIngressError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<RevokeCacheSecurityGroupIngressError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"AuthorizationNotFound" => {
return RusotoError::Service(
RevokeCacheSecurityGroupIngressError::AuthorizationNotFoundFault(
parsed_error.message,
),
)
}
"CacheSecurityGroupNotFound" => {
return RusotoError::Service(
RevokeCacheSecurityGroupIngressError::CacheSecurityGroupNotFoundFault(
parsed_error.message,
),
)
}
"InvalidCacheSecurityGroupState" => return RusotoError::Service(
RevokeCacheSecurityGroupIngressError::InvalidCacheSecurityGroupStateFault(
parsed_error.message,
),
),
"InvalidParameterCombination" => {
return RusotoError::Service(
RevokeCacheSecurityGroupIngressError::InvalidParameterCombination(
parsed_error.message,
),
)
}
"InvalidParameterValue" => {
return RusotoError::Service(
RevokeCacheSecurityGroupIngressError::InvalidParameterValue(
parsed_error.message,
),
)
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for RevokeCacheSecurityGroupIngressError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
RevokeCacheSecurityGroupIngressError::AuthorizationNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
RevokeCacheSecurityGroupIngressError::CacheSecurityGroupNotFoundFault(ref cause) => {
write!(f, "{}", cause)
}
RevokeCacheSecurityGroupIngressError::InvalidCacheSecurityGroupStateFault(
ref cause,
) => write!(f, "{}", cause),
RevokeCacheSecurityGroupIngressError::InvalidParameterCombination(ref cause) => {
write!(f, "{}", cause)
}
RevokeCacheSecurityGroupIngressError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for RevokeCacheSecurityGroupIngressError {}
#[derive(Debug, PartialEq)]
pub enum StartMigrationError {
InvalidParameterValue(String),
InvalidReplicationGroupStateFault(String),
ReplicationGroupAlreadyUnderMigrationFault(String),
ReplicationGroupNotFoundFault(String),
}
impl StartMigrationError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<StartMigrationError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"InvalidParameterValue" => {
return RusotoError::Service(StartMigrationError::InvalidParameterValue(
parsed_error.message,
))
}
"InvalidReplicationGroupState" => {
return RusotoError::Service(
StartMigrationError::InvalidReplicationGroupStateFault(
parsed_error.message,
),
)
}
"ReplicationGroupAlreadyUnderMigrationFault" => {
return RusotoError::Service(
StartMigrationError::ReplicationGroupAlreadyUnderMigrationFault(
parsed_error.message,
),
)
}
"ReplicationGroupNotFoundFault" => {
return RusotoError::Service(
StartMigrationError::ReplicationGroupNotFoundFault(
parsed_error.message,
),
)
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for StartMigrationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
StartMigrationError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
StartMigrationError::InvalidReplicationGroupStateFault(ref cause) => {
write!(f, "{}", cause)
}
StartMigrationError::ReplicationGroupAlreadyUnderMigrationFault(ref cause) => {
write!(f, "{}", cause)
}
StartMigrationError::ReplicationGroupNotFoundFault(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for StartMigrationError {}
#[derive(Debug, PartialEq)]
pub enum TestFailoverError {
APICallRateForCustomerExceededFault(String),
InvalidCacheClusterStateFault(String),
InvalidKMSKeyFault(String),
InvalidParameterCombination(String),
InvalidParameterValue(String),
InvalidReplicationGroupStateFault(String),
NodeGroupNotFoundFault(String),
ReplicationGroupNotFoundFault(String),
TestFailoverNotAvailableFault(String),
}
impl TestFailoverError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<TestFailoverError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"APICallRateForCustomerExceeded" => {
return RusotoError::Service(
TestFailoverError::APICallRateForCustomerExceededFault(
parsed_error.message,
),
)
}
"InvalidCacheClusterState" => {
return RusotoError::Service(
TestFailoverError::InvalidCacheClusterStateFault(parsed_error.message),
)
}
"InvalidKMSKeyFault" => {
return RusotoError::Service(TestFailoverError::InvalidKMSKeyFault(
parsed_error.message,
))
}
"InvalidParameterCombination" => {
return RusotoError::Service(
TestFailoverError::InvalidParameterCombination(parsed_error.message),
)
}
"InvalidParameterValue" => {
return RusotoError::Service(TestFailoverError::InvalidParameterValue(
parsed_error.message,
))
}
"InvalidReplicationGroupState" => {
return RusotoError::Service(
TestFailoverError::InvalidReplicationGroupStateFault(
parsed_error.message,
),
)
}
"NodeGroupNotFoundFault" => {
return RusotoError::Service(TestFailoverError::NodeGroupNotFoundFault(
parsed_error.message,
))
}
"ReplicationGroupNotFoundFault" => {
return RusotoError::Service(
TestFailoverError::ReplicationGroupNotFoundFault(parsed_error.message),
)
}
"TestFailoverNotAvailableFault" => {
return RusotoError::Service(
TestFailoverError::TestFailoverNotAvailableFault(parsed_error.message),
)
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for TestFailoverError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
TestFailoverError::APICallRateForCustomerExceededFault(ref cause) => {
write!(f, "{}", cause)
}
TestFailoverError::InvalidCacheClusterStateFault(ref cause) => write!(f, "{}", cause),
TestFailoverError::InvalidKMSKeyFault(ref cause) => write!(f, "{}", cause),
TestFailoverError::InvalidParameterCombination(ref cause) => write!(f, "{}", cause),
TestFailoverError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
TestFailoverError::InvalidReplicationGroupStateFault(ref cause) => {
write!(f, "{}", cause)
}
TestFailoverError::NodeGroupNotFoundFault(ref cause) => write!(f, "{}", cause),
TestFailoverError::ReplicationGroupNotFoundFault(ref cause) => write!(f, "{}", cause),
TestFailoverError::TestFailoverNotAvailableFault(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for TestFailoverError {}
#[async_trait]
pub trait ElastiCache {
async fn add_tags_to_resource(
&self,
input: AddTagsToResourceMessage,
) -> Result<TagListMessage, RusotoError<AddTagsToResourceError>>;
async fn authorize_cache_security_group_ingress(
&self,
input: AuthorizeCacheSecurityGroupIngressMessage,
) -> Result<
AuthorizeCacheSecurityGroupIngressResult,
RusotoError<AuthorizeCacheSecurityGroupIngressError>,
>;
async fn batch_apply_update_action(
&self,
input: BatchApplyUpdateActionMessage,
) -> Result<UpdateActionResultsMessage, RusotoError<BatchApplyUpdateActionError>>;
async fn batch_stop_update_action(
&self,
input: BatchStopUpdateActionMessage,
) -> Result<UpdateActionResultsMessage, RusotoError<BatchStopUpdateActionError>>;
async fn complete_migration(
&self,
input: CompleteMigrationMessage,
) -> Result<CompleteMigrationResponse, RusotoError<CompleteMigrationError>>;
async fn copy_snapshot(
&self,
input: CopySnapshotMessage,
) -> Result<CopySnapshotResult, RusotoError<CopySnapshotError>>;
async fn create_cache_cluster(
&self,
input: CreateCacheClusterMessage,
) -> Result<CreateCacheClusterResult, RusotoError<CreateCacheClusterError>>;
async fn create_cache_parameter_group(
&self,
input: CreateCacheParameterGroupMessage,
) -> Result<CreateCacheParameterGroupResult, RusotoError<CreateCacheParameterGroupError>>;
async fn create_cache_security_group(
&self,
input: CreateCacheSecurityGroupMessage,
) -> Result<CreateCacheSecurityGroupResult, RusotoError<CreateCacheSecurityGroupError>>;
async fn create_cache_subnet_group(
&self,
input: CreateCacheSubnetGroupMessage,
) -> Result<CreateCacheSubnetGroupResult, RusotoError<CreateCacheSubnetGroupError>>;
async fn create_global_replication_group(
&self,
input: CreateGlobalReplicationGroupMessage,
) -> Result<CreateGlobalReplicationGroupResult, RusotoError<CreateGlobalReplicationGroupError>>;
async fn create_replication_group(
&self,
input: CreateReplicationGroupMessage,
) -> Result<CreateReplicationGroupResult, RusotoError<CreateReplicationGroupError>>;
async fn create_snapshot(
&self,
input: CreateSnapshotMessage,
) -> Result<CreateSnapshotResult, RusotoError<CreateSnapshotError>>;
async fn decrease_node_groups_in_global_replication_group(
&self,
input: DecreaseNodeGroupsInGlobalReplicationGroupMessage,
) -> Result<
DecreaseNodeGroupsInGlobalReplicationGroupResult,
RusotoError<DecreaseNodeGroupsInGlobalReplicationGroupError>,
>;
async fn decrease_replica_count(
&self,
input: DecreaseReplicaCountMessage,
) -> Result<DecreaseReplicaCountResult, RusotoError<DecreaseReplicaCountError>>;
async fn delete_cache_cluster(
&self,
input: DeleteCacheClusterMessage,
) -> Result<DeleteCacheClusterResult, RusotoError<DeleteCacheClusterError>>;
async fn delete_cache_parameter_group(
&self,
input: DeleteCacheParameterGroupMessage,
) -> Result<(), RusotoError<DeleteCacheParameterGroupError>>;
async fn delete_cache_security_group(
&self,
input: DeleteCacheSecurityGroupMessage,
) -> Result<(), RusotoError<DeleteCacheSecurityGroupError>>;
async fn delete_cache_subnet_group(
&self,
input: DeleteCacheSubnetGroupMessage,
) -> Result<(), RusotoError<DeleteCacheSubnetGroupError>>;
async fn delete_global_replication_group(
&self,
input: DeleteGlobalReplicationGroupMessage,
) -> Result<DeleteGlobalReplicationGroupResult, RusotoError<DeleteGlobalReplicationGroupError>>;
async fn delete_replication_group(
&self,
input: DeleteReplicationGroupMessage,
) -> Result<DeleteReplicationGroupResult, RusotoError<DeleteReplicationGroupError>>;
async fn delete_snapshot(
&self,
input: DeleteSnapshotMessage,
) -> Result<DeleteSnapshotResult, RusotoError<DeleteSnapshotError>>;
async fn describe_cache_clusters(
&self,
input: DescribeCacheClustersMessage,
) -> Result<CacheClusterMessage, RusotoError<DescribeCacheClustersError>>;
async fn describe_cache_engine_versions(
&self,
input: DescribeCacheEngineVersionsMessage,
) -> Result<CacheEngineVersionMessage, RusotoError<DescribeCacheEngineVersionsError>>;
async fn describe_cache_parameter_groups(
&self,
input: DescribeCacheParameterGroupsMessage,
) -> Result<CacheParameterGroupsMessage, RusotoError<DescribeCacheParameterGroupsError>>;
async fn describe_cache_parameters(
&self,
input: DescribeCacheParametersMessage,
) -> Result<CacheParameterGroupDetails, RusotoError<DescribeCacheParametersError>>;
async fn describe_cache_security_groups(
&self,
input: DescribeCacheSecurityGroupsMessage,
) -> Result<CacheSecurityGroupMessage, RusotoError<DescribeCacheSecurityGroupsError>>;
async fn describe_cache_subnet_groups(
&self,
input: DescribeCacheSubnetGroupsMessage,
) -> Result<CacheSubnetGroupMessage, RusotoError<DescribeCacheSubnetGroupsError>>;
async fn describe_engine_default_parameters(
&self,
input: DescribeEngineDefaultParametersMessage,
) -> Result<
DescribeEngineDefaultParametersResult,
RusotoError<DescribeEngineDefaultParametersError>,
>;
async fn describe_events(
&self,
input: DescribeEventsMessage,
) -> Result<EventsMessage, RusotoError<DescribeEventsError>>;
async fn describe_global_replication_groups(
&self,
input: DescribeGlobalReplicationGroupsMessage,
) -> Result<
DescribeGlobalReplicationGroupsResult,
RusotoError<DescribeGlobalReplicationGroupsError>,
>;
async fn describe_replication_groups(
&self,
input: DescribeReplicationGroupsMessage,
) -> Result<ReplicationGroupMessage, RusotoError<DescribeReplicationGroupsError>>;
async fn describe_reserved_cache_nodes(
&self,
input: DescribeReservedCacheNodesMessage,
) -> Result<ReservedCacheNodeMessage, RusotoError<DescribeReservedCacheNodesError>>;
async fn describe_reserved_cache_nodes_offerings(
&self,
input: DescribeReservedCacheNodesOfferingsMessage,
) -> Result<
ReservedCacheNodesOfferingMessage,
RusotoError<DescribeReservedCacheNodesOfferingsError>,
>;
async fn describe_service_updates(
&self,
input: DescribeServiceUpdatesMessage,
) -> Result<ServiceUpdatesMessage, RusotoError<DescribeServiceUpdatesError>>;
async fn describe_snapshots(
&self,
input: DescribeSnapshotsMessage,
) -> Result<DescribeSnapshotsListMessage, RusotoError<DescribeSnapshotsError>>;
async fn describe_update_actions(
&self,
input: DescribeUpdateActionsMessage,
) -> Result<UpdateActionsMessage, RusotoError<DescribeUpdateActionsError>>;
async fn disassociate_global_replication_group(
&self,
input: DisassociateGlobalReplicationGroupMessage,
) -> Result<
DisassociateGlobalReplicationGroupResult,
RusotoError<DisassociateGlobalReplicationGroupError>,
>;
async fn failover_global_replication_group(
&self,
input: FailoverGlobalReplicationGroupMessage,
) -> Result<
FailoverGlobalReplicationGroupResult,
RusotoError<FailoverGlobalReplicationGroupError>,
>;
async fn increase_node_groups_in_global_replication_group(
&self,
input: IncreaseNodeGroupsInGlobalReplicationGroupMessage,
) -> Result<
IncreaseNodeGroupsInGlobalReplicationGroupResult,
RusotoError<IncreaseNodeGroupsInGlobalReplicationGroupError>,
>;
async fn increase_replica_count(
&self,
input: IncreaseReplicaCountMessage,
) -> Result<IncreaseReplicaCountResult, RusotoError<IncreaseReplicaCountError>>;
async fn list_allowed_node_type_modifications(
&self,
input: ListAllowedNodeTypeModificationsMessage,
) -> Result<
AllowedNodeTypeModificationsMessage,
RusotoError<ListAllowedNodeTypeModificationsError>,
>;
async fn list_tags_for_resource(
&self,
input: ListTagsForResourceMessage,
) -> Result<TagListMessage, RusotoError<ListTagsForResourceError>>;
async fn modify_cache_cluster(
&self,
input: ModifyCacheClusterMessage,
) -> Result<ModifyCacheClusterResult, RusotoError<ModifyCacheClusterError>>;
async fn modify_cache_parameter_group(
&self,
input: ModifyCacheParameterGroupMessage,
) -> Result<CacheParameterGroupNameMessage, RusotoError<ModifyCacheParameterGroupError>>;
async fn modify_cache_subnet_group(
&self,
input: ModifyCacheSubnetGroupMessage,
) -> Result<ModifyCacheSubnetGroupResult, RusotoError<ModifyCacheSubnetGroupError>>;
async fn modify_global_replication_group(
&self,
input: ModifyGlobalReplicationGroupMessage,
) -> Result<ModifyGlobalReplicationGroupResult, RusotoError<ModifyGlobalReplicationGroupError>>;
async fn modify_replication_group(
&self,
input: ModifyReplicationGroupMessage,
) -> Result<ModifyReplicationGroupResult, RusotoError<ModifyReplicationGroupError>>;
async fn modify_replication_group_shard_configuration(
&self,
input: ModifyReplicationGroupShardConfigurationMessage,
) -> Result<
ModifyReplicationGroupShardConfigurationResult,
RusotoError<ModifyReplicationGroupShardConfigurationError>,
>;
async fn purchase_reserved_cache_nodes_offering(
&self,
input: PurchaseReservedCacheNodesOfferingMessage,
) -> Result<
PurchaseReservedCacheNodesOfferingResult,
RusotoError<PurchaseReservedCacheNodesOfferingError>,
>;
async fn rebalance_slots_in_global_replication_group(
&self,
input: RebalanceSlotsInGlobalReplicationGroupMessage,
) -> Result<
RebalanceSlotsInGlobalReplicationGroupResult,
RusotoError<RebalanceSlotsInGlobalReplicationGroupError>,
>;
async fn reboot_cache_cluster(
&self,
input: RebootCacheClusterMessage,
) -> Result<RebootCacheClusterResult, RusotoError<RebootCacheClusterError>>;
async fn remove_tags_from_resource(
&self,
input: RemoveTagsFromResourceMessage,
) -> Result<TagListMessage, RusotoError<RemoveTagsFromResourceError>>;
async fn reset_cache_parameter_group(
&self,
input: ResetCacheParameterGroupMessage,
) -> Result<CacheParameterGroupNameMessage, RusotoError<ResetCacheParameterGroupError>>;
async fn revoke_cache_security_group_ingress(
&self,
input: RevokeCacheSecurityGroupIngressMessage,
) -> Result<
RevokeCacheSecurityGroupIngressResult,
RusotoError<RevokeCacheSecurityGroupIngressError>,
>;
async fn start_migration(
&self,
input: StartMigrationMessage,
) -> Result<StartMigrationResponse, RusotoError<StartMigrationError>>;
async fn test_failover(
&self,
input: TestFailoverMessage,
) -> Result<TestFailoverResult, RusotoError<TestFailoverError>>;
}
#[derive(Clone)]
pub struct ElastiCacheClient {
client: Client,
region: region::Region,
}
impl ElastiCacheClient {
pub fn new(region: region::Region) -> ElastiCacheClient {
ElastiCacheClient {
client: Client::shared(),
region,
}
}
pub fn new_with<P, D>(
request_dispatcher: D,
credentials_provider: P,
region: region::Region,
) -> ElastiCacheClient
where
P: ProvideAwsCredentials + Send + Sync + 'static,
D: DispatchSignedRequest + Send + Sync + 'static,
{
ElastiCacheClient {
client: Client::new_with(credentials_provider, request_dispatcher),
region,
}
}
pub fn new_with_client(client: Client, region: region::Region) -> ElastiCacheClient {
ElastiCacheClient { client, region }
}
}
#[async_trait]
impl ElastiCache for ElastiCacheClient {
async fn add_tags_to_resource(
&self,
input: AddTagsToResourceMessage,
) -> Result<TagListMessage, RusotoError<AddTagsToResourceError>> {
let mut request = SignedRequest::new("POST", "elasticache", &self.region, "/");
let params = self.new_params("AddTagsToResource");
let mut params = params;
AddTagsToResourceMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, AddTagsToResourceError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result = TagListMessageDeserializer::deserialize("AddTagsToResourceResult", stack)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn authorize_cache_security_group_ingress(
&self,
input: AuthorizeCacheSecurityGroupIngressMessage,
) -> Result<
AuthorizeCacheSecurityGroupIngressResult,
RusotoError<AuthorizeCacheSecurityGroupIngressError>,
> {
let mut request = SignedRequest::new("POST", "elasticache", &self.region, "/");
let params = self.new_params("AuthorizeCacheSecurityGroupIngress");
let mut params = params;
AuthorizeCacheSecurityGroupIngressMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(
request,
AuthorizeCacheSecurityGroupIngressError::from_response,
)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result = AuthorizeCacheSecurityGroupIngressResultDeserializer::deserialize(
"AuthorizeCacheSecurityGroupIngressResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn batch_apply_update_action(
&self,
input: BatchApplyUpdateActionMessage,
) -> Result<UpdateActionResultsMessage, RusotoError<BatchApplyUpdateActionError>> {
let mut request = SignedRequest::new("POST", "elasticache", &self.region, "/");
let params = self.new_params("BatchApplyUpdateAction");
let mut params = params;
BatchApplyUpdateActionMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, BatchApplyUpdateActionError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result = UpdateActionResultsMessageDeserializer::deserialize(
"BatchApplyUpdateActionResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn batch_stop_update_action(
&self,
input: BatchStopUpdateActionMessage,
) -> Result<UpdateActionResultsMessage, RusotoError<BatchStopUpdateActionError>> {
let mut request = SignedRequest::new("POST", "elasticache", &self.region, "/");
let params = self.new_params("BatchStopUpdateAction");
let mut params = params;
BatchStopUpdateActionMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, BatchStopUpdateActionError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result = UpdateActionResultsMessageDeserializer::deserialize(
"BatchStopUpdateActionResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn complete_migration(
&self,
input: CompleteMigrationMessage,
) -> Result<CompleteMigrationResponse, RusotoError<CompleteMigrationError>> {
let mut request = SignedRequest::new("POST", "elasticache", &self.region, "/");
let params = self.new_params("CompleteMigration");
let mut params = params;
CompleteMigrationMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, CompleteMigrationError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result = CompleteMigrationResponseDeserializer::deserialize(
"CompleteMigrationResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn copy_snapshot(
&self,
input: CopySnapshotMessage,
) -> Result<CopySnapshotResult, RusotoError<CopySnapshotError>> {
let mut request = SignedRequest::new("POST", "elasticache", &self.region, "/");
let params = self.new_params("CopySnapshot");
let mut params = params;
CopySnapshotMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, CopySnapshotError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result = CopySnapshotResultDeserializer::deserialize("CopySnapshotResult", stack)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn create_cache_cluster(
&self,
input: CreateCacheClusterMessage,
) -> Result<CreateCacheClusterResult, RusotoError<CreateCacheClusterError>> {
let mut request = SignedRequest::new("POST", "elasticache", &self.region, "/");
let params = self.new_params("CreateCacheCluster");
let mut params = params;
CreateCacheClusterMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, CreateCacheClusterError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result = CreateCacheClusterResultDeserializer::deserialize(
"CreateCacheClusterResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn create_cache_parameter_group(
&self,
input: CreateCacheParameterGroupMessage,
) -> Result<CreateCacheParameterGroupResult, RusotoError<CreateCacheParameterGroupError>> {
let mut request = SignedRequest::new("POST", "elasticache", &self.region, "/");
let params = self.new_params("CreateCacheParameterGroup");
let mut params = params;
CreateCacheParameterGroupMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, CreateCacheParameterGroupError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result = CreateCacheParameterGroupResultDeserializer::deserialize(
"CreateCacheParameterGroupResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn create_cache_security_group(
&self,
input: CreateCacheSecurityGroupMessage,
) -> Result<CreateCacheSecurityGroupResult, RusotoError<CreateCacheSecurityGroupError>> {
let mut request = SignedRequest::new("POST", "elasticache", &self.region, "/");
let params = self.new_params("CreateCacheSecurityGroup");
let mut params = params;
CreateCacheSecurityGroupMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, CreateCacheSecurityGroupError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result = CreateCacheSecurityGroupResultDeserializer::deserialize(
"CreateCacheSecurityGroupResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn create_cache_subnet_group(
&self,
input: CreateCacheSubnetGroupMessage,
) -> Result<CreateCacheSubnetGroupResult, RusotoError<CreateCacheSubnetGroupError>> {
let mut request = SignedRequest::new("POST", "elasticache", &self.region, "/");
let params = self.new_params("CreateCacheSubnetGroup");
let mut params = params;
CreateCacheSubnetGroupMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, CreateCacheSubnetGroupError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result = CreateCacheSubnetGroupResultDeserializer::deserialize(
"CreateCacheSubnetGroupResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn create_global_replication_group(
&self,
input: CreateGlobalReplicationGroupMessage,
) -> Result<CreateGlobalReplicationGroupResult, RusotoError<CreateGlobalReplicationGroupError>>
{
let mut request = SignedRequest::new("POST", "elasticache", &self.region, "/");
let params = self.new_params("CreateGlobalReplicationGroup");
let mut params = params;
CreateGlobalReplicationGroupMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, CreateGlobalReplicationGroupError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result = CreateGlobalReplicationGroupResultDeserializer::deserialize(
"CreateGlobalReplicationGroupResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn create_replication_group(
&self,
input: CreateReplicationGroupMessage,
) -> Result<CreateReplicationGroupResult, RusotoError<CreateReplicationGroupError>> {
let mut request = SignedRequest::new("POST", "elasticache", &self.region, "/");
let params = self.new_params("CreateReplicationGroup");
let mut params = params;
CreateReplicationGroupMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, CreateReplicationGroupError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result = CreateReplicationGroupResultDeserializer::deserialize(
"CreateReplicationGroupResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn create_snapshot(
&self,
input: CreateSnapshotMessage,
) -> Result<CreateSnapshotResult, RusotoError<CreateSnapshotError>> {
let mut request = SignedRequest::new("POST", "elasticache", &self.region, "/");
let params = self.new_params("CreateSnapshot");
let mut params = params;
CreateSnapshotMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, CreateSnapshotError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result =
CreateSnapshotResultDeserializer::deserialize("CreateSnapshotResult", stack)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn decrease_node_groups_in_global_replication_group(
&self,
input: DecreaseNodeGroupsInGlobalReplicationGroupMessage,
) -> Result<
DecreaseNodeGroupsInGlobalReplicationGroupResult,
RusotoError<DecreaseNodeGroupsInGlobalReplicationGroupError>,
> {
let mut request = SignedRequest::new("POST", "elasticache", &self.region, "/");
let params = self.new_params("DecreaseNodeGroupsInGlobalReplicationGroup");
let mut params = params;
DecreaseNodeGroupsInGlobalReplicationGroupMessageSerializer::serialize(
&mut params,
"",
&input,
);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(
request,
DecreaseNodeGroupsInGlobalReplicationGroupError::from_response,
)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result = DecreaseNodeGroupsInGlobalReplicationGroupResultDeserializer::deserialize(
"DecreaseNodeGroupsInGlobalReplicationGroupResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn decrease_replica_count(
&self,
input: DecreaseReplicaCountMessage,
) -> Result<DecreaseReplicaCountResult, RusotoError<DecreaseReplicaCountError>> {
let mut request = SignedRequest::new("POST", "elasticache", &self.region, "/");
let params = self.new_params("DecreaseReplicaCount");
let mut params = params;
DecreaseReplicaCountMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, DecreaseReplicaCountError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result = DecreaseReplicaCountResultDeserializer::deserialize(
"DecreaseReplicaCountResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn delete_cache_cluster(
&self,
input: DeleteCacheClusterMessage,
) -> Result<DeleteCacheClusterResult, RusotoError<DeleteCacheClusterError>> {
let mut request = SignedRequest::new("POST", "elasticache", &self.region, "/");
let params = self.new_params("DeleteCacheCluster");
let mut params = params;
DeleteCacheClusterMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, DeleteCacheClusterError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result = DeleteCacheClusterResultDeserializer::deserialize(
"DeleteCacheClusterResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn delete_cache_parameter_group(
&self,
input: DeleteCacheParameterGroupMessage,
) -> Result<(), RusotoError<DeleteCacheParameterGroupError>> {
let mut request = SignedRequest::new("POST", "elasticache", &self.region, "/");
let params = self.new_params("DeleteCacheParameterGroup");
let mut params = params;
DeleteCacheParameterGroupMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, DeleteCacheParameterGroupError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
async fn delete_cache_security_group(
&self,
input: DeleteCacheSecurityGroupMessage,
) -> Result<(), RusotoError<DeleteCacheSecurityGroupError>> {
let mut request = SignedRequest::new("POST", "elasticache", &self.region, "/");
let params = self.new_params("DeleteCacheSecurityGroup");
let mut params = params;
DeleteCacheSecurityGroupMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, DeleteCacheSecurityGroupError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
async fn delete_cache_subnet_group(
&self,
input: DeleteCacheSubnetGroupMessage,
) -> Result<(), RusotoError<DeleteCacheSubnetGroupError>> {
let mut request = SignedRequest::new("POST", "elasticache", &self.region, "/");
let params = self.new_params("DeleteCacheSubnetGroup");
let mut params = params;
DeleteCacheSubnetGroupMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, DeleteCacheSubnetGroupError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
async fn delete_global_replication_group(
&self,
input: DeleteGlobalReplicationGroupMessage,
) -> Result<DeleteGlobalReplicationGroupResult, RusotoError<DeleteGlobalReplicationGroupError>>
{
let mut request = SignedRequest::new("POST", "elasticache", &self.region, "/");
let params = self.new_params("DeleteGlobalReplicationGroup");
let mut params = params;
DeleteGlobalReplicationGroupMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, DeleteGlobalReplicationGroupError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result = DeleteGlobalReplicationGroupResultDeserializer::deserialize(
"DeleteGlobalReplicationGroupResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn delete_replication_group(
&self,
input: DeleteReplicationGroupMessage,
) -> Result<DeleteReplicationGroupResult, RusotoError<DeleteReplicationGroupError>> {
let mut request = SignedRequest::new("POST", "elasticache", &self.region, "/");
let params = self.new_params("DeleteReplicationGroup");
let mut params = params;
DeleteReplicationGroupMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, DeleteReplicationGroupError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result = DeleteReplicationGroupResultDeserializer::deserialize(
"DeleteReplicationGroupResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn delete_snapshot(
&self,
input: DeleteSnapshotMessage,
) -> Result<DeleteSnapshotResult, RusotoError<DeleteSnapshotError>> {
let mut request = SignedRequest::new("POST", "elasticache", &self.region, "/");
let params = self.new_params("DeleteSnapshot");
let mut params = params;
DeleteSnapshotMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, DeleteSnapshotError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result =
DeleteSnapshotResultDeserializer::deserialize("DeleteSnapshotResult", stack)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn describe_cache_clusters(
&self,
input: DescribeCacheClustersMessage,
) -> Result<CacheClusterMessage, RusotoError<DescribeCacheClustersError>> {
let mut request = SignedRequest::new("POST", "elasticache", &self.region, "/");
let params = self.new_params("DescribeCacheClusters");
let mut params = params;
DescribeCacheClustersMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, DescribeCacheClustersError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result =
CacheClusterMessageDeserializer::deserialize("DescribeCacheClustersResult", stack)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn describe_cache_engine_versions(
&self,
input: DescribeCacheEngineVersionsMessage,
) -> Result<CacheEngineVersionMessage, RusotoError<DescribeCacheEngineVersionsError>> {
let mut request = SignedRequest::new("POST", "elasticache", &self.region, "/");
let params = self.new_params("DescribeCacheEngineVersions");
let mut params = params;
DescribeCacheEngineVersionsMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, DescribeCacheEngineVersionsError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result = CacheEngineVersionMessageDeserializer::deserialize(
"DescribeCacheEngineVersionsResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn describe_cache_parameter_groups(
&self,
input: DescribeCacheParameterGroupsMessage,
) -> Result<CacheParameterGroupsMessage, RusotoError<DescribeCacheParameterGroupsError>> {
let mut request = SignedRequest::new("POST", "elasticache", &self.region, "/");
let params = self.new_params("DescribeCacheParameterGroups");
let mut params = params;
DescribeCacheParameterGroupsMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, DescribeCacheParameterGroupsError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result = CacheParameterGroupsMessageDeserializer::deserialize(
"DescribeCacheParameterGroupsResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn describe_cache_parameters(
&self,
input: DescribeCacheParametersMessage,
) -> Result<CacheParameterGroupDetails, RusotoError<DescribeCacheParametersError>> {
let mut request = SignedRequest::new("POST", "elasticache", &self.region, "/");
let params = self.new_params("DescribeCacheParameters");
let mut params = params;
DescribeCacheParametersMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, DescribeCacheParametersError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result = CacheParameterGroupDetailsDeserializer::deserialize(
"DescribeCacheParametersResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn describe_cache_security_groups(
&self,
input: DescribeCacheSecurityGroupsMessage,
) -> Result<CacheSecurityGroupMessage, RusotoError<DescribeCacheSecurityGroupsError>> {
let mut request = SignedRequest::new("POST", "elasticache", &self.region, "/");
let params = self.new_params("DescribeCacheSecurityGroups");
let mut params = params;
DescribeCacheSecurityGroupsMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, DescribeCacheSecurityGroupsError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result = CacheSecurityGroupMessageDeserializer::deserialize(
"DescribeCacheSecurityGroupsResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn describe_cache_subnet_groups(
&self,
input: DescribeCacheSubnetGroupsMessage,
) -> Result<CacheSubnetGroupMessage, RusotoError<DescribeCacheSubnetGroupsError>> {
let mut request = SignedRequest::new("POST", "elasticache", &self.region, "/");
let params = self.new_params("DescribeCacheSubnetGroups");
let mut params = params;
DescribeCacheSubnetGroupsMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, DescribeCacheSubnetGroupsError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result = CacheSubnetGroupMessageDeserializer::deserialize(
"DescribeCacheSubnetGroupsResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn describe_engine_default_parameters(
&self,
input: DescribeEngineDefaultParametersMessage,
) -> Result<
DescribeEngineDefaultParametersResult,
RusotoError<DescribeEngineDefaultParametersError>,
> {
let mut request = SignedRequest::new("POST", "elasticache", &self.region, "/");
let params = self.new_params("DescribeEngineDefaultParameters");
let mut params = params;
DescribeEngineDefaultParametersMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, DescribeEngineDefaultParametersError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result = DescribeEngineDefaultParametersResultDeserializer::deserialize(
"DescribeEngineDefaultParametersResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn describe_events(
&self,
input: DescribeEventsMessage,
) -> Result<EventsMessage, RusotoError<DescribeEventsError>> {
let mut request = SignedRequest::new("POST", "elasticache", &self.region, "/");
let params = self.new_params("DescribeEvents");
let mut params = params;
DescribeEventsMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, DescribeEventsError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result = EventsMessageDeserializer::deserialize("DescribeEventsResult", stack)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn describe_global_replication_groups(
&self,
input: DescribeGlobalReplicationGroupsMessage,
) -> Result<
DescribeGlobalReplicationGroupsResult,
RusotoError<DescribeGlobalReplicationGroupsError>,
> {
let mut request = SignedRequest::new("POST", "elasticache", &self.region, "/");
let params = self.new_params("DescribeGlobalReplicationGroups");
let mut params = params;
DescribeGlobalReplicationGroupsMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, DescribeGlobalReplicationGroupsError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result = DescribeGlobalReplicationGroupsResultDeserializer::deserialize(
"DescribeGlobalReplicationGroupsResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn describe_replication_groups(
&self,
input: DescribeReplicationGroupsMessage,
) -> Result<ReplicationGroupMessage, RusotoError<DescribeReplicationGroupsError>> {
let mut request = SignedRequest::new("POST", "elasticache", &self.region, "/");
let params = self.new_params("DescribeReplicationGroups");
let mut params = params;
DescribeReplicationGroupsMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, DescribeReplicationGroupsError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result = ReplicationGroupMessageDeserializer::deserialize(
"DescribeReplicationGroupsResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn describe_reserved_cache_nodes(
&self,
input: DescribeReservedCacheNodesMessage,
) -> Result<ReservedCacheNodeMessage, RusotoError<DescribeReservedCacheNodesError>> {
let mut request = SignedRequest::new("POST", "elasticache", &self.region, "/");
let params = self.new_params("DescribeReservedCacheNodes");
let mut params = params;
DescribeReservedCacheNodesMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, DescribeReservedCacheNodesError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result = ReservedCacheNodeMessageDeserializer::deserialize(
"DescribeReservedCacheNodesResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn describe_reserved_cache_nodes_offerings(
&self,
input: DescribeReservedCacheNodesOfferingsMessage,
) -> Result<
ReservedCacheNodesOfferingMessage,
RusotoError<DescribeReservedCacheNodesOfferingsError>,
> {
let mut request = SignedRequest::new("POST", "elasticache", &self.region, "/");
let params = self.new_params("DescribeReservedCacheNodesOfferings");
let mut params = params;
DescribeReservedCacheNodesOfferingsMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(
request,
DescribeReservedCacheNodesOfferingsError::from_response,
)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result = ReservedCacheNodesOfferingMessageDeserializer::deserialize(
"DescribeReservedCacheNodesOfferingsResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn describe_service_updates(
&self,
input: DescribeServiceUpdatesMessage,
) -> Result<ServiceUpdatesMessage, RusotoError<DescribeServiceUpdatesError>> {
let mut request = SignedRequest::new("POST", "elasticache", &self.region, "/");
let params = self.new_params("DescribeServiceUpdates");
let mut params = params;
DescribeServiceUpdatesMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, DescribeServiceUpdatesError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result = ServiceUpdatesMessageDeserializer::deserialize(
"DescribeServiceUpdatesResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn describe_snapshots(
&self,
input: DescribeSnapshotsMessage,
) -> Result<DescribeSnapshotsListMessage, RusotoError<DescribeSnapshotsError>> {
let mut request = SignedRequest::new("POST", "elasticache", &self.region, "/");
let params = self.new_params("DescribeSnapshots");
let mut params = params;
DescribeSnapshotsMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, DescribeSnapshotsError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result = DescribeSnapshotsListMessageDeserializer::deserialize(
"DescribeSnapshotsResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn describe_update_actions(
&self,
input: DescribeUpdateActionsMessage,
) -> Result<UpdateActionsMessage, RusotoError<DescribeUpdateActionsError>> {
let mut request = SignedRequest::new("POST", "elasticache", &self.region, "/");
let params = self.new_params("DescribeUpdateActions");
let mut params = params;
DescribeUpdateActionsMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, DescribeUpdateActionsError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result = UpdateActionsMessageDeserializer::deserialize(
"DescribeUpdateActionsResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn disassociate_global_replication_group(
&self,
input: DisassociateGlobalReplicationGroupMessage,
) -> Result<
DisassociateGlobalReplicationGroupResult,
RusotoError<DisassociateGlobalReplicationGroupError>,
> {
let mut request = SignedRequest::new("POST", "elasticache", &self.region, "/");
let params = self.new_params("DisassociateGlobalReplicationGroup");
let mut params = params;
DisassociateGlobalReplicationGroupMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(
request,
DisassociateGlobalReplicationGroupError::from_response,
)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result = DisassociateGlobalReplicationGroupResultDeserializer::deserialize(
"DisassociateGlobalReplicationGroupResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn failover_global_replication_group(
&self,
input: FailoverGlobalReplicationGroupMessage,
) -> Result<
FailoverGlobalReplicationGroupResult,
RusotoError<FailoverGlobalReplicationGroupError>,
> {
let mut request = SignedRequest::new("POST", "elasticache", &self.region, "/");
let params = self.new_params("FailoverGlobalReplicationGroup");
let mut params = params;
FailoverGlobalReplicationGroupMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, FailoverGlobalReplicationGroupError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result = FailoverGlobalReplicationGroupResultDeserializer::deserialize(
"FailoverGlobalReplicationGroupResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn increase_node_groups_in_global_replication_group(
&self,
input: IncreaseNodeGroupsInGlobalReplicationGroupMessage,
) -> Result<
IncreaseNodeGroupsInGlobalReplicationGroupResult,
RusotoError<IncreaseNodeGroupsInGlobalReplicationGroupError>,
> {
let mut request = SignedRequest::new("POST", "elasticache", &self.region, "/");
let params = self.new_params("IncreaseNodeGroupsInGlobalReplicationGroup");
let mut params = params;
IncreaseNodeGroupsInGlobalReplicationGroupMessageSerializer::serialize(
&mut params,
"",
&input,
);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(
request,
IncreaseNodeGroupsInGlobalReplicationGroupError::from_response,
)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result = IncreaseNodeGroupsInGlobalReplicationGroupResultDeserializer::deserialize(
"IncreaseNodeGroupsInGlobalReplicationGroupResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn increase_replica_count(
&self,
input: IncreaseReplicaCountMessage,
) -> Result<IncreaseReplicaCountResult, RusotoError<IncreaseReplicaCountError>> {
let mut request = SignedRequest::new("POST", "elasticache", &self.region, "/");
let params = self.new_params("IncreaseReplicaCount");
let mut params = params;
IncreaseReplicaCountMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, IncreaseReplicaCountError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result = IncreaseReplicaCountResultDeserializer::deserialize(
"IncreaseReplicaCountResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn list_allowed_node_type_modifications(
&self,
input: ListAllowedNodeTypeModificationsMessage,
) -> Result<
AllowedNodeTypeModificationsMessage,
RusotoError<ListAllowedNodeTypeModificationsError>,
> {
let mut request = SignedRequest::new("POST", "elasticache", &self.region, "/");
let params = self.new_params("ListAllowedNodeTypeModifications");
let mut params = params;
ListAllowedNodeTypeModificationsMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(
request,
ListAllowedNodeTypeModificationsError::from_response,
)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result = AllowedNodeTypeModificationsMessageDeserializer::deserialize(
"ListAllowedNodeTypeModificationsResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn list_tags_for_resource(
&self,
input: ListTagsForResourceMessage,
) -> Result<TagListMessage, RusotoError<ListTagsForResourceError>> {
let mut request = SignedRequest::new("POST", "elasticache", &self.region, "/");
let params = self.new_params("ListTagsForResource");
let mut params = params;
ListTagsForResourceMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, ListTagsForResourceError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result =
TagListMessageDeserializer::deserialize("ListTagsForResourceResult", stack)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn modify_cache_cluster(
&self,
input: ModifyCacheClusterMessage,
) -> Result<ModifyCacheClusterResult, RusotoError<ModifyCacheClusterError>> {
let mut request = SignedRequest::new("POST", "elasticache", &self.region, "/");
let params = self.new_params("ModifyCacheCluster");
let mut params = params;
ModifyCacheClusterMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, ModifyCacheClusterError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result = ModifyCacheClusterResultDeserializer::deserialize(
"ModifyCacheClusterResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn modify_cache_parameter_group(
&self,
input: ModifyCacheParameterGroupMessage,
) -> Result<CacheParameterGroupNameMessage, RusotoError<ModifyCacheParameterGroupError>> {
let mut request = SignedRequest::new("POST", "elasticache", &self.region, "/");
let params = self.new_params("ModifyCacheParameterGroup");
let mut params = params;
ModifyCacheParameterGroupMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, ModifyCacheParameterGroupError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result = CacheParameterGroupNameMessageDeserializer::deserialize(
"ModifyCacheParameterGroupResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn modify_cache_subnet_group(
&self,
input: ModifyCacheSubnetGroupMessage,
) -> Result<ModifyCacheSubnetGroupResult, RusotoError<ModifyCacheSubnetGroupError>> {
let mut request = SignedRequest::new("POST", "elasticache", &self.region, "/");
let params = self.new_params("ModifyCacheSubnetGroup");
let mut params = params;
ModifyCacheSubnetGroupMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, ModifyCacheSubnetGroupError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result = ModifyCacheSubnetGroupResultDeserializer::deserialize(
"ModifyCacheSubnetGroupResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn modify_global_replication_group(
&self,
input: ModifyGlobalReplicationGroupMessage,
) -> Result<ModifyGlobalReplicationGroupResult, RusotoError<ModifyGlobalReplicationGroupError>>
{
let mut request = SignedRequest::new("POST", "elasticache", &self.region, "/");
let params = self.new_params("ModifyGlobalReplicationGroup");
let mut params = params;
ModifyGlobalReplicationGroupMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, ModifyGlobalReplicationGroupError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result = ModifyGlobalReplicationGroupResultDeserializer::deserialize(
"ModifyGlobalReplicationGroupResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn modify_replication_group(
&self,
input: ModifyReplicationGroupMessage,
) -> Result<ModifyReplicationGroupResult, RusotoError<ModifyReplicationGroupError>> {
let mut request = SignedRequest::new("POST", "elasticache", &self.region, "/");
let params = self.new_params("ModifyReplicationGroup");
let mut params = params;
ModifyReplicationGroupMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, ModifyReplicationGroupError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result = ModifyReplicationGroupResultDeserializer::deserialize(
"ModifyReplicationGroupResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn modify_replication_group_shard_configuration(
&self,
input: ModifyReplicationGroupShardConfigurationMessage,
) -> Result<
ModifyReplicationGroupShardConfigurationResult,
RusotoError<ModifyReplicationGroupShardConfigurationError>,
> {
let mut request = SignedRequest::new("POST", "elasticache", &self.region, "/");
let params = self.new_params("ModifyReplicationGroupShardConfiguration");
let mut params = params;
ModifyReplicationGroupShardConfigurationMessageSerializer::serialize(
&mut params,
"",
&input,
);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(
request,
ModifyReplicationGroupShardConfigurationError::from_response,
)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result = ModifyReplicationGroupShardConfigurationResultDeserializer::deserialize(
"ModifyReplicationGroupShardConfigurationResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn purchase_reserved_cache_nodes_offering(
&self,
input: PurchaseReservedCacheNodesOfferingMessage,
) -> Result<
PurchaseReservedCacheNodesOfferingResult,
RusotoError<PurchaseReservedCacheNodesOfferingError>,
> {
let mut request = SignedRequest::new("POST", "elasticache", &self.region, "/");
let params = self.new_params("PurchaseReservedCacheNodesOffering");
let mut params = params;
PurchaseReservedCacheNodesOfferingMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(
request,
PurchaseReservedCacheNodesOfferingError::from_response,
)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result = PurchaseReservedCacheNodesOfferingResultDeserializer::deserialize(
"PurchaseReservedCacheNodesOfferingResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn rebalance_slots_in_global_replication_group(
&self,
input: RebalanceSlotsInGlobalReplicationGroupMessage,
) -> Result<
RebalanceSlotsInGlobalReplicationGroupResult,
RusotoError<RebalanceSlotsInGlobalReplicationGroupError>,
> {
let mut request = SignedRequest::new("POST", "elasticache", &self.region, "/");
let params = self.new_params("RebalanceSlotsInGlobalReplicationGroup");
let mut params = params;
RebalanceSlotsInGlobalReplicationGroupMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(
request,
RebalanceSlotsInGlobalReplicationGroupError::from_response,
)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result = RebalanceSlotsInGlobalReplicationGroupResultDeserializer::deserialize(
"RebalanceSlotsInGlobalReplicationGroupResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn reboot_cache_cluster(
&self,
input: RebootCacheClusterMessage,
) -> Result<RebootCacheClusterResult, RusotoError<RebootCacheClusterError>> {
let mut request = SignedRequest::new("POST", "elasticache", &self.region, "/");
let params = self.new_params("RebootCacheCluster");
let mut params = params;
RebootCacheClusterMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, RebootCacheClusterError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result = RebootCacheClusterResultDeserializer::deserialize(
"RebootCacheClusterResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn remove_tags_from_resource(
&self,
input: RemoveTagsFromResourceMessage,
) -> Result<TagListMessage, RusotoError<RemoveTagsFromResourceError>> {
let mut request = SignedRequest::new("POST", "elasticache", &self.region, "/");
let params = self.new_params("RemoveTagsFromResource");
let mut params = params;
RemoveTagsFromResourceMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, RemoveTagsFromResourceError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result =
TagListMessageDeserializer::deserialize("RemoveTagsFromResourceResult", stack)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn reset_cache_parameter_group(
&self,
input: ResetCacheParameterGroupMessage,
) -> Result<CacheParameterGroupNameMessage, RusotoError<ResetCacheParameterGroupError>> {
let mut request = SignedRequest::new("POST", "elasticache", &self.region, "/");
let params = self.new_params("ResetCacheParameterGroup");
let mut params = params;
ResetCacheParameterGroupMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, ResetCacheParameterGroupError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result = CacheParameterGroupNameMessageDeserializer::deserialize(
"ResetCacheParameterGroupResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn revoke_cache_security_group_ingress(
&self,
input: RevokeCacheSecurityGroupIngressMessage,
) -> Result<
RevokeCacheSecurityGroupIngressResult,
RusotoError<RevokeCacheSecurityGroupIngressError>,
> {
let mut request = SignedRequest::new("POST", "elasticache", &self.region, "/");
let params = self.new_params("RevokeCacheSecurityGroupIngress");
let mut params = params;
RevokeCacheSecurityGroupIngressMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, RevokeCacheSecurityGroupIngressError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result = RevokeCacheSecurityGroupIngressResultDeserializer::deserialize(
"RevokeCacheSecurityGroupIngressResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn start_migration(
&self,
input: StartMigrationMessage,
) -> Result<StartMigrationResponse, RusotoError<StartMigrationError>> {
let mut request = SignedRequest::new("POST", "elasticache", &self.region, "/");
let params = self.new_params("StartMigration");
let mut params = params;
StartMigrationMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, StartMigrationError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result =
StartMigrationResponseDeserializer::deserialize("StartMigrationResult", stack)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn test_failover(
&self,
input: TestFailoverMessage,
) -> Result<TestFailoverResult, RusotoError<TestFailoverError>> {
let mut request = SignedRequest::new("POST", "elasticache", &self.region, "/");
let params = self.new_params("TestFailover");
let mut params = params;
TestFailoverMessageSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, TestFailoverError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
xml_util::start_element(actual_tag_name, stack)?;
let result = TestFailoverResultDeserializer::deserialize("TestFailoverResult", stack)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
}