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 SnsClient {
fn new_params(&self, operation_name: &str) -> Params {
let mut params = Params::new();
params.put("Action", operation_name);
params.put("Version", "2010-03-31");
params
}
async fn sign_and_dispatch<E>(
&self,
request: SignedRequest,
from_response: fn(BufferedHttpResponse) -> RusotoError<E>,
) -> Result<HttpResponse, RusotoError<E>> {
let mut response = self.client.sign_and_dispatch(request).await?;
if !response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
return Err(from_response(response));
}
Ok(response)
}
}
#[allow(dead_code)]
struct AccountDeserializer;
impl AccountDeserializer {
#[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 ActionsListSerializer;
impl ActionsListSerializer {
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 AddPermissionInput {
pub aws_account_id: Vec<String>,
pub action_name: Vec<String>,
pub label: String,
pub topic_arn: String,
}
struct AddPermissionInputSerializer;
impl AddPermissionInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &AddPermissionInput) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
DelegatesListSerializer::serialize(
params,
&format!("{}{}", prefix, "AWSAccountId"),
&obj.aws_account_id,
);
ActionsListSerializer::serialize(
params,
&format!("{}{}", prefix, "ActionName"),
&obj.action_name,
);
params.put(&format!("{}{}", prefix, "Label"), &obj.label);
params.put(&format!("{}{}", prefix, "TopicArn"), &obj.topic_arn);
}
}
#[allow(dead_code)]
struct AttributeNameDeserializer;
impl AttributeNameDeserializer {
#[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 AttributeValueDeserializer;
impl AttributeValueDeserializer {
#[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 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()))
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CheckIfPhoneNumberIsOptedOutInput {
pub phone_number: String,
}
struct CheckIfPhoneNumberIsOptedOutInputSerializer;
impl CheckIfPhoneNumberIsOptedOutInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CheckIfPhoneNumberIsOptedOutInput) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(&format!("{}{}", prefix, "phoneNumber"), &obj.phone_number);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct CheckIfPhoneNumberIsOptedOutResponse {
pub is_opted_out: Option<bool>,
}
#[allow(dead_code)]
struct CheckIfPhoneNumberIsOptedOutResponseDeserializer;
impl CheckIfPhoneNumberIsOptedOutResponseDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CheckIfPhoneNumberIsOptedOutResponse, XmlParseError> {
deserialize_elements::<_, CheckIfPhoneNumberIsOptedOutResponse, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"isOptedOut" => {
obj.is_opted_out =
Some(BooleanDeserializer::deserialize("isOptedOut", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ConfirmSubscriptionInput {
pub authenticate_on_unsubscribe: Option<String>,
pub token: String,
pub topic_arn: String,
}
struct ConfirmSubscriptionInputSerializer;
impl ConfirmSubscriptionInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ConfirmSubscriptionInput) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.authenticate_on_unsubscribe {
params.put(
&format!("{}{}", prefix, "AuthenticateOnUnsubscribe"),
&field_value,
);
}
params.put(&format!("{}{}", prefix, "Token"), &obj.token);
params.put(&format!("{}{}", prefix, "TopicArn"), &obj.topic_arn);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct ConfirmSubscriptionResponse {
pub subscription_arn: Option<String>,
}
#[allow(dead_code)]
struct ConfirmSubscriptionResponseDeserializer;
impl ConfirmSubscriptionResponseDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ConfirmSubscriptionResponse, XmlParseError> {
deserialize_elements::<_, ConfirmSubscriptionResponse, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"SubscriptionArn" => {
obj.subscription_arn = Some(SubscriptionARNDeserializer::deserialize(
"SubscriptionArn",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct CreateEndpointResponse {
pub endpoint_arn: Option<String>,
}
#[allow(dead_code)]
struct CreateEndpointResponseDeserializer;
impl CreateEndpointResponseDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CreateEndpointResponse, XmlParseError> {
deserialize_elements::<_, CreateEndpointResponse, _>(tag_name, stack, |name, stack, obj| {
match name {
"EndpointArn" => {
obj.endpoint_arn = Some(StringDeserializer::deserialize("EndpointArn", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreatePlatformApplicationInput {
pub attributes: ::std::collections::HashMap<String, String>,
pub name: String,
pub platform: String,
}
struct CreatePlatformApplicationInputSerializer;
impl CreatePlatformApplicationInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CreatePlatformApplicationInput) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
MapStringToStringSerializer::serialize(
params,
&format!("{}{}.entry", prefix, "Attributes"),
&obj.attributes,
);
params.put(&format!("{}{}", prefix, "Name"), &obj.name);
params.put(&format!("{}{}", prefix, "Platform"), &obj.platform);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct CreatePlatformApplicationResponse {
pub platform_application_arn: Option<String>,
}
#[allow(dead_code)]
struct CreatePlatformApplicationResponseDeserializer;
impl CreatePlatformApplicationResponseDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CreatePlatformApplicationResponse, XmlParseError> {
deserialize_elements::<_, CreatePlatformApplicationResponse, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"PlatformApplicationArn" => {
obj.platform_application_arn = Some(StringDeserializer::deserialize(
"PlatformApplicationArn",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreatePlatformEndpointInput {
pub attributes: Option<::std::collections::HashMap<String, String>>,
pub custom_user_data: Option<String>,
pub platform_application_arn: String,
pub token: String,
}
struct CreatePlatformEndpointInputSerializer;
impl CreatePlatformEndpointInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CreatePlatformEndpointInput) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.attributes {
MapStringToStringSerializer::serialize(
params,
&format!("{}{}.entry", prefix, "Attributes"),
field_value,
);
}
if let Some(ref field_value) = obj.custom_user_data {
params.put(&format!("{}{}", prefix, "CustomUserData"), &field_value);
}
params.put(
&format!("{}{}", prefix, "PlatformApplicationArn"),
&obj.platform_application_arn,
);
params.put(&format!("{}{}", prefix, "Token"), &obj.token);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateTopicInput {
pub attributes: Option<::std::collections::HashMap<String, String>>,
pub name: String,
pub tags: Option<Vec<Tag>>,
}
struct CreateTopicInputSerializer;
impl CreateTopicInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &CreateTopicInput) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.attributes {
TopicAttributesMapSerializer::serialize(
params,
&format!("{}{}", prefix, "Attributes"),
field_value,
);
}
params.put(&format!("{}{}", prefix, "Name"), &obj.name);
if let Some(ref field_value) = obj.tags {
TagListSerializer::serialize(params, &format!("{}{}", prefix, "Tags"), field_value);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct CreateTopicResponse {
pub topic_arn: Option<String>,
}
#[allow(dead_code)]
struct CreateTopicResponseDeserializer;
impl CreateTopicResponseDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CreateTopicResponse, XmlParseError> {
deserialize_elements::<_, CreateTopicResponse, _>(tag_name, stack, |name, stack, obj| {
match name {
"TopicArn" => {
obj.topic_arn = Some(TopicARNDeserializer::deserialize("TopicArn", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct DelegatesListSerializer;
impl DelegatesListSerializer {
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 DeleteEndpointInput {
pub endpoint_arn: String,
}
struct DeleteEndpointInputSerializer;
impl DeleteEndpointInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DeleteEndpointInput) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(&format!("{}{}", prefix, "EndpointArn"), &obj.endpoint_arn);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeletePlatformApplicationInput {
pub platform_application_arn: String,
}
struct DeletePlatformApplicationInputSerializer;
impl DeletePlatformApplicationInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DeletePlatformApplicationInput) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "PlatformApplicationArn"),
&obj.platform_application_arn,
);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteTopicInput {
pub topic_arn: String,
}
struct DeleteTopicInputSerializer;
impl DeleteTopicInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &DeleteTopicInput) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(&format!("{}{}", prefix, "TopicArn"), &obj.topic_arn);
}
}
#[allow(dead_code)]
struct EndpointDeserializer;
impl EndpointDeserializer {
#[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 GetEndpointAttributesInput {
pub endpoint_arn: String,
}
struct GetEndpointAttributesInputSerializer;
impl GetEndpointAttributesInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &GetEndpointAttributesInput) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(&format!("{}{}", prefix, "EndpointArn"), &obj.endpoint_arn);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct GetEndpointAttributesResponse {
pub attributes: Option<::std::collections::HashMap<String, String>>,
}
#[allow(dead_code)]
struct GetEndpointAttributesResponseDeserializer;
impl GetEndpointAttributesResponseDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<GetEndpointAttributesResponse, XmlParseError> {
deserialize_elements::<_, GetEndpointAttributesResponse, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"Attributes" => {
obj.attributes = Some(MapStringToStringDeserializer::deserialize(
"Attributes",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetPlatformApplicationAttributesInput {
pub platform_application_arn: String,
}
struct GetPlatformApplicationAttributesInputSerializer;
impl GetPlatformApplicationAttributesInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &GetPlatformApplicationAttributesInput) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "PlatformApplicationArn"),
&obj.platform_application_arn,
);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct GetPlatformApplicationAttributesResponse {
pub attributes: Option<::std::collections::HashMap<String, String>>,
}
#[allow(dead_code)]
struct GetPlatformApplicationAttributesResponseDeserializer;
impl GetPlatformApplicationAttributesResponseDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<GetPlatformApplicationAttributesResponse, XmlParseError> {
deserialize_elements::<_, GetPlatformApplicationAttributesResponse, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"Attributes" => {
obj.attributes = Some(MapStringToStringDeserializer::deserialize(
"Attributes",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetSMSAttributesInput {
pub attributes: Option<Vec<String>>,
}
struct GetSMSAttributesInputSerializer;
impl GetSMSAttributesInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &GetSMSAttributesInput) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.attributes {
ListStringSerializer::serialize(
params,
&format!("{}{}", prefix, "attributes"),
field_value,
);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct GetSMSAttributesResponse {
pub attributes: Option<::std::collections::HashMap<String, String>>,
}
#[allow(dead_code)]
struct GetSMSAttributesResponseDeserializer;
impl GetSMSAttributesResponseDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<GetSMSAttributesResponse, XmlParseError> {
deserialize_elements::<_, GetSMSAttributesResponse, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"attributes" => {
obj.attributes = Some(MapStringToStringDeserializer::deserialize(
"attributes",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetSubscriptionAttributesInput {
pub subscription_arn: String,
}
struct GetSubscriptionAttributesInputSerializer;
impl GetSubscriptionAttributesInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &GetSubscriptionAttributesInput) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "SubscriptionArn"),
&obj.subscription_arn,
);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct GetSubscriptionAttributesResponse {
pub attributes: Option<::std::collections::HashMap<String, String>>,
}
#[allow(dead_code)]
struct GetSubscriptionAttributesResponseDeserializer;
impl GetSubscriptionAttributesResponseDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<GetSubscriptionAttributesResponse, XmlParseError> {
deserialize_elements::<_, GetSubscriptionAttributesResponse, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"Attributes" => {
obj.attributes = Some(SubscriptionAttributesMapDeserializer::deserialize(
"Attributes",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetTopicAttributesInput {
pub topic_arn: String,
}
struct GetTopicAttributesInputSerializer;
impl GetTopicAttributesInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &GetTopicAttributesInput) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(&format!("{}{}", prefix, "TopicArn"), &obj.topic_arn);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct GetTopicAttributesResponse {
pub attributes: Option<::std::collections::HashMap<String, String>>,
}
#[allow(dead_code)]
struct GetTopicAttributesResponseDeserializer;
impl GetTopicAttributesResponseDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<GetTopicAttributesResponse, XmlParseError> {
deserialize_elements::<_, GetTopicAttributesResponse, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"Attributes" => {
obj.attributes = Some(TopicAttributesMapDeserializer::deserialize(
"Attributes",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListEndpointsByPlatformApplicationInput {
pub next_token: Option<String>,
pub platform_application_arn: String,
}
struct ListEndpointsByPlatformApplicationInputSerializer;
impl ListEndpointsByPlatformApplicationInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ListEndpointsByPlatformApplicationInput) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.next_token {
params.put(&format!("{}{}", prefix, "NextToken"), &field_value);
}
params.put(
&format!("{}{}", prefix, "PlatformApplicationArn"),
&obj.platform_application_arn,
);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct ListEndpointsByPlatformApplicationResponse {
pub endpoints: Option<Vec<String>>,
pub next_token: Option<String>,
}
#[allow(dead_code)]
struct ListEndpointsByPlatformApplicationResponseDeserializer;
impl ListEndpointsByPlatformApplicationResponseDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ListEndpointsByPlatformApplicationResponse, XmlParseError> {
deserialize_elements::<_, ListEndpointsByPlatformApplicationResponse, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"Endpoints" => {
obj.endpoints.get_or_insert(vec![]).extend(
ListOfEndpointsDeserializer::deserialize("Endpoints", stack)?,
);
}
"NextToken" => {
obj.next_token = Some(StringDeserializer::deserialize("NextToken", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[allow(dead_code)]
struct ListOfEndpointsDeserializer;
impl ListOfEndpointsDeserializer {
#[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(EndpointDeserializer::deserialize("member", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[allow(dead_code)]
struct ListOfPlatformApplicationsDeserializer;
impl ListOfPlatformApplicationsDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<PlatformApplication>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "member" {
obj.push(PlatformApplicationDeserializer::deserialize(
"member", stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListPhoneNumbersOptedOutInput {
pub next_token: Option<String>,
}
struct ListPhoneNumbersOptedOutInputSerializer;
impl ListPhoneNumbersOptedOutInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ListPhoneNumbersOptedOutInput) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.next_token {
params.put(&format!("{}{}", prefix, "nextToken"), &field_value);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct ListPhoneNumbersOptedOutResponse {
pub next_token: Option<String>,
pub phone_numbers: Option<Vec<String>>,
}
#[allow(dead_code)]
struct ListPhoneNumbersOptedOutResponseDeserializer;
impl ListPhoneNumbersOptedOutResponseDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ListPhoneNumbersOptedOutResponse, XmlParseError> {
deserialize_elements::<_, ListPhoneNumbersOptedOutResponse, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"nextToken" => {
obj.next_token = Some(StringDeserializer::deserialize("nextToken", stack)?);
}
"phoneNumbers" => {
obj.phone_numbers.get_or_insert(vec![]).extend(
PhoneNumberListDeserializer::deserialize("phoneNumbers", stack)?,
);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListPlatformApplicationsInput {
pub next_token: Option<String>,
}
struct ListPlatformApplicationsInputSerializer;
impl ListPlatformApplicationsInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ListPlatformApplicationsInput) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.next_token {
params.put(&format!("{}{}", prefix, "NextToken"), &field_value);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct ListPlatformApplicationsResponse {
pub next_token: Option<String>,
pub platform_applications: Option<Vec<PlatformApplication>>,
}
#[allow(dead_code)]
struct ListPlatformApplicationsResponseDeserializer;
impl ListPlatformApplicationsResponseDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ListPlatformApplicationsResponse, XmlParseError> {
deserialize_elements::<_, ListPlatformApplicationsResponse, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"NextToken" => {
obj.next_token = Some(StringDeserializer::deserialize("NextToken", stack)?);
}
"PlatformApplications" => {
obj.platform_applications.get_or_insert(vec![]).extend(
ListOfPlatformApplicationsDeserializer::deserialize(
"PlatformApplications",
stack,
)?,
);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
struct ListStringSerializer;
impl ListStringSerializer {
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 ListSubscriptionsByTopicInput {
pub next_token: Option<String>,
pub topic_arn: String,
}
struct ListSubscriptionsByTopicInputSerializer;
impl ListSubscriptionsByTopicInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ListSubscriptionsByTopicInput) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.next_token {
params.put(&format!("{}{}", prefix, "NextToken"), &field_value);
}
params.put(&format!("{}{}", prefix, "TopicArn"), &obj.topic_arn);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct ListSubscriptionsByTopicResponse {
pub next_token: Option<String>,
pub subscriptions: Option<Vec<Subscription>>,
}
#[allow(dead_code)]
struct ListSubscriptionsByTopicResponseDeserializer;
impl ListSubscriptionsByTopicResponseDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ListSubscriptionsByTopicResponse, XmlParseError> {
deserialize_elements::<_, ListSubscriptionsByTopicResponse, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"NextToken" => {
obj.next_token =
Some(NextTokenDeserializer::deserialize("NextToken", stack)?);
}
"Subscriptions" => {
obj.subscriptions.get_or_insert(vec![]).extend(
SubscriptionsListDeserializer::deserialize("Subscriptions", stack)?,
);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListSubscriptionsInput {
pub next_token: Option<String>,
}
struct ListSubscriptionsInputSerializer;
impl ListSubscriptionsInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ListSubscriptionsInput) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.next_token {
params.put(&format!("{}{}", prefix, "NextToken"), &field_value);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct ListSubscriptionsResponse {
pub next_token: Option<String>,
pub subscriptions: Option<Vec<Subscription>>,
}
#[allow(dead_code)]
struct ListSubscriptionsResponseDeserializer;
impl ListSubscriptionsResponseDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ListSubscriptionsResponse, XmlParseError> {
deserialize_elements::<_, ListSubscriptionsResponse, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"NextToken" => {
obj.next_token =
Some(NextTokenDeserializer::deserialize("NextToken", stack)?);
}
"Subscriptions" => {
obj.subscriptions.get_or_insert(vec![]).extend(
SubscriptionsListDeserializer::deserialize("Subscriptions", stack)?,
);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListTagsForResourceRequest {
pub resource_arn: String,
}
struct ListTagsForResourceRequestSerializer;
impl ListTagsForResourceRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ListTagsForResourceRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(&format!("{}{}", prefix, "ResourceArn"), &obj.resource_arn);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct ListTagsForResourceResponse {
pub tags: Option<Vec<Tag>>,
}
#[allow(dead_code)]
struct ListTagsForResourceResponseDeserializer;
impl ListTagsForResourceResponseDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ListTagsForResourceResponse, XmlParseError> {
deserialize_elements::<_, ListTagsForResourceResponse, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"Tags" => {
obj.tags
.get_or_insert(vec![])
.extend(TagListDeserializer::deserialize("Tags", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListTopicsInput {
pub next_token: Option<String>,
}
struct ListTopicsInputSerializer;
impl ListTopicsInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &ListTopicsInput) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.next_token {
params.put(&format!("{}{}", prefix, "NextToken"), &field_value);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct ListTopicsResponse {
pub next_token: Option<String>,
pub topics: Option<Vec<Topic>>,
}
#[allow(dead_code)]
struct ListTopicsResponseDeserializer;
impl ListTopicsResponseDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ListTopicsResponse, XmlParseError> {
deserialize_elements::<_, ListTopicsResponse, _>(tag_name, stack, |name, stack, obj| {
match name {
"NextToken" => {
obj.next_token = Some(NextTokenDeserializer::deserialize("NextToken", stack)?);
}
"Topics" => {
obj.topics
.get_or_insert(vec![])
.extend(TopicsListDeserializer::deserialize("Topics", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[allow(dead_code)]
struct MapStringToStringDeserializer;
impl MapStringToStringDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<::std::collections::HashMap<String, String>, XmlParseError> {
xml_util::start_element(tag_name, stack)?;
let mut obj = ::std::collections::HashMap::new();
while xml_util::peek_at_name(stack)? == "entry" {
xml_util::start_element("entry", stack)?;
let key = StringDeserializer::deserialize("key", stack)?;
let value = StringDeserializer::deserialize("value", stack)?;
obj.insert(key, value);
xml_util::end_element("entry", stack)?;
}
xml_util::end_element(tag_name, stack)?;
Ok(obj)
}
}
struct MapStringToStringSerializer;
impl MapStringToStringSerializer {
fn serialize(
params: &mut Params,
name: &str,
obj: &::std::collections::HashMap<String, String>,
) {
for (index, (key, value)) in obj.iter().enumerate() {
let prefix = format!("{}.{}", name, index + 1);
params.put(&format!("{}.{}", prefix, "key"), &key);
params.put(&format!("{}.{}", prefix, "value"), &value);
}
}
}
struct MessageAttributeMapSerializer;
impl MessageAttributeMapSerializer {
fn serialize(
params: &mut Params,
name: &str,
obj: &::std::collections::HashMap<String, MessageAttributeValue>,
) {
for (index, (key, value)) in obj.iter().enumerate() {
let prefix = format!("{}.entry.{}", name, index + 1);
params.put(&format!("{}.{}", prefix, "Name"), &key);
MessageAttributeValueSerializer::serialize(
params,
&format!("{}.{}", prefix, "Value"),
value,
);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct MessageAttributeValue {
pub binary_value: Option<bytes::Bytes>,
pub data_type: String,
pub string_value: Option<String>,
}
struct MessageAttributeValueSerializer;
impl MessageAttributeValueSerializer {
fn serialize(params: &mut Params, name: &str, obj: &MessageAttributeValue) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.binary_value {
params.put(
&format!("{}{}", prefix, "BinaryValue"),
::std::str::from_utf8(&field_value).unwrap(),
);
}
params.put(&format!("{}{}", prefix, "DataType"), &obj.data_type);
if let Some(ref field_value) = obj.string_value {
params.put(&format!("{}{}", prefix, "StringValue"), &field_value);
}
}
}
#[allow(dead_code)]
struct MessageIdDeserializer;
impl MessageIdDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[allow(dead_code)]
struct NextTokenDeserializer;
impl NextTokenDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct OptInPhoneNumberInput {
pub phone_number: String,
}
struct OptInPhoneNumberInputSerializer;
impl OptInPhoneNumberInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &OptInPhoneNumberInput) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(&format!("{}{}", prefix, "phoneNumber"), &obj.phone_number);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct OptInPhoneNumberResponse {}
#[allow(dead_code)]
struct OptInPhoneNumberResponseDeserializer;
impl OptInPhoneNumberResponseDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<OptInPhoneNumberResponse, XmlParseError> {
xml_util::start_element(tag_name, stack)?;
let obj = OptInPhoneNumberResponse::default();
xml_util::end_element(tag_name, stack)?;
Ok(obj)
}
}
#[allow(dead_code)]
struct PhoneNumberDeserializer;
impl PhoneNumberDeserializer {
#[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 PhoneNumberListDeserializer;
impl PhoneNumberListDeserializer {
#[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(PhoneNumberDeserializer::deserialize("member", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct PlatformApplication {
pub attributes: Option<::std::collections::HashMap<String, String>>,
pub platform_application_arn: Option<String>,
}
#[allow(dead_code)]
struct PlatformApplicationDeserializer;
impl PlatformApplicationDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<PlatformApplication, XmlParseError> {
deserialize_elements::<_, PlatformApplication, _>(tag_name, stack, |name, stack, obj| {
match name {
"Attributes" => {
obj.attributes = Some(MapStringToStringDeserializer::deserialize(
"Attributes",
stack,
)?);
}
"PlatformApplicationArn" => {
obj.platform_application_arn = Some(StringDeserializer::deserialize(
"PlatformApplicationArn",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[allow(dead_code)]
struct ProtocolDeserializer;
impl ProtocolDeserializer {
#[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 PublishInput {
pub message: String,
pub message_attributes: Option<::std::collections::HashMap<String, MessageAttributeValue>>,
pub message_deduplication_id: Option<String>,
pub message_group_id: Option<String>,
pub message_structure: Option<String>,
pub phone_number: Option<String>,
pub subject: Option<String>,
pub target_arn: Option<String>,
pub topic_arn: Option<String>,
}
struct PublishInputSerializer;
impl PublishInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &PublishInput) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(&format!("{}{}", prefix, "Message"), &obj.message);
if let Some(ref field_value) = obj.message_attributes {
MessageAttributeMapSerializer::serialize(
params,
&format!("{}{}", prefix, "MessageAttributes"),
field_value,
);
}
if let Some(ref field_value) = obj.message_deduplication_id {
params.put(
&format!("{}{}", prefix, "MessageDeduplicationId"),
&field_value,
);
}
if let Some(ref field_value) = obj.message_group_id {
params.put(&format!("{}{}", prefix, "MessageGroupId"), &field_value);
}
if let Some(ref field_value) = obj.message_structure {
params.put(&format!("{}{}", prefix, "MessageStructure"), &field_value);
}
if let Some(ref field_value) = obj.phone_number {
params.put(&format!("{}{}", prefix, "PhoneNumber"), &field_value);
}
if let Some(ref field_value) = obj.subject {
params.put(&format!("{}{}", prefix, "Subject"), &field_value);
}
if let Some(ref field_value) = obj.target_arn {
params.put(&format!("{}{}", prefix, "TargetArn"), &field_value);
}
if let Some(ref field_value) = obj.topic_arn {
params.put(&format!("{}{}", prefix, "TopicArn"), &field_value);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct PublishResponse {
pub message_id: Option<String>,
pub sequence_number: Option<String>,
}
#[allow(dead_code)]
struct PublishResponseDeserializer;
impl PublishResponseDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<PublishResponse, XmlParseError> {
deserialize_elements::<_, PublishResponse, _>(tag_name, stack, |name, stack, obj| {
match name {
"MessageId" => {
obj.message_id = Some(MessageIdDeserializer::deserialize("MessageId", stack)?);
}
"SequenceNumber" => {
obj.sequence_number =
Some(StringDeserializer::deserialize("SequenceNumber", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct RemovePermissionInput {
pub label: String,
pub topic_arn: String,
}
struct RemovePermissionInputSerializer;
impl RemovePermissionInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &RemovePermissionInput) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(&format!("{}{}", prefix, "Label"), &obj.label);
params.put(&format!("{}{}", prefix, "TopicArn"), &obj.topic_arn);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct SetEndpointAttributesInput {
pub attributes: ::std::collections::HashMap<String, String>,
pub endpoint_arn: String,
}
struct SetEndpointAttributesInputSerializer;
impl SetEndpointAttributesInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &SetEndpointAttributesInput) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
MapStringToStringSerializer::serialize(
params,
&format!("{}{}.entry", prefix, "Attributes"),
&obj.attributes,
);
params.put(&format!("{}{}", prefix, "EndpointArn"), &obj.endpoint_arn);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct SetPlatformApplicationAttributesInput {
pub attributes: ::std::collections::HashMap<String, String>,
pub platform_application_arn: String,
}
struct SetPlatformApplicationAttributesInputSerializer;
impl SetPlatformApplicationAttributesInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &SetPlatformApplicationAttributesInput) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
MapStringToStringSerializer::serialize(
params,
&format!("{}{}.entry", prefix, "Attributes"),
&obj.attributes,
);
params.put(
&format!("{}{}", prefix, "PlatformApplicationArn"),
&obj.platform_application_arn,
);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct SetSMSAttributesInput {
pub attributes: ::std::collections::HashMap<String, String>,
}
struct SetSMSAttributesInputSerializer;
impl SetSMSAttributesInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &SetSMSAttributesInput) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
MapStringToStringSerializer::serialize(
params,
&format!("{}{}.entry", prefix, "attributes"),
&obj.attributes,
);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct SetSMSAttributesResponse {}
#[allow(dead_code)]
struct SetSMSAttributesResponseDeserializer;
impl SetSMSAttributesResponseDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<SetSMSAttributesResponse, XmlParseError> {
xml_util::start_element(tag_name, stack)?;
let obj = SetSMSAttributesResponse::default();
xml_util::end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct SetSubscriptionAttributesInput {
pub attribute_name: String,
pub attribute_value: Option<String>,
pub subscription_arn: String,
}
struct SetSubscriptionAttributesInputSerializer;
impl SetSubscriptionAttributesInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &SetSubscriptionAttributesInput) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "AttributeName"),
&obj.attribute_name,
);
if let Some(ref field_value) = obj.attribute_value {
params.put(&format!("{}{}", prefix, "AttributeValue"), &field_value);
}
params.put(
&format!("{}{}", prefix, "SubscriptionArn"),
&obj.subscription_arn,
);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct SetTopicAttributesInput {
pub attribute_name: String,
pub attribute_value: Option<String>,
pub topic_arn: String,
}
struct SetTopicAttributesInputSerializer;
impl SetTopicAttributesInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &SetTopicAttributesInput) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "AttributeName"),
&obj.attribute_name,
);
if let Some(ref field_value) = obj.attribute_value {
params.put(&format!("{}{}", prefix, "AttributeValue"), &field_value);
}
params.put(&format!("{}{}", prefix, "TopicArn"), &obj.topic_arn);
}
}
#[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 = "deserialize_structs", derive(Deserialize))]
pub struct SubscribeInput {
pub attributes: Option<::std::collections::HashMap<String, String>>,
pub endpoint: Option<String>,
pub protocol: String,
pub return_subscription_arn: Option<bool>,
pub topic_arn: String,
}
struct SubscribeInputSerializer;
impl SubscribeInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &SubscribeInput) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
if let Some(ref field_value) = obj.attributes {
SubscriptionAttributesMapSerializer::serialize(
params,
&format!("{}{}", prefix, "Attributes"),
field_value,
);
}
if let Some(ref field_value) = obj.endpoint {
params.put(&format!("{}{}", prefix, "Endpoint"), &field_value);
}
params.put(&format!("{}{}", prefix, "Protocol"), &obj.protocol);
if let Some(ref field_value) = obj.return_subscription_arn {
params.put(
&format!("{}{}", prefix, "ReturnSubscriptionArn"),
&field_value,
);
}
params.put(&format!("{}{}", prefix, "TopicArn"), &obj.topic_arn);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct SubscribeResponse {
pub subscription_arn: Option<String>,
}
#[allow(dead_code)]
struct SubscribeResponseDeserializer;
impl SubscribeResponseDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<SubscribeResponse, XmlParseError> {
deserialize_elements::<_, SubscribeResponse, _>(tag_name, stack, |name, stack, obj| {
match name {
"SubscriptionArn" => {
obj.subscription_arn = Some(SubscriptionARNDeserializer::deserialize(
"SubscriptionArn",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct Subscription {
pub endpoint: Option<String>,
pub owner: Option<String>,
pub protocol: Option<String>,
pub subscription_arn: Option<String>,
pub topic_arn: Option<String>,
}
#[allow(dead_code)]
struct SubscriptionDeserializer;
impl SubscriptionDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Subscription, XmlParseError> {
deserialize_elements::<_, Subscription, _>(tag_name, stack, |name, stack, obj| {
match name {
"Endpoint" => {
obj.endpoint = Some(EndpointDeserializer::deserialize("Endpoint", stack)?);
}
"Owner" => {
obj.owner = Some(AccountDeserializer::deserialize("Owner", stack)?);
}
"Protocol" => {
obj.protocol = Some(ProtocolDeserializer::deserialize("Protocol", stack)?);
}
"SubscriptionArn" => {
obj.subscription_arn = Some(SubscriptionARNDeserializer::deserialize(
"SubscriptionArn",
stack,
)?);
}
"TopicArn" => {
obj.topic_arn = Some(TopicARNDeserializer::deserialize("TopicArn", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[allow(dead_code)]
struct SubscriptionARNDeserializer;
impl SubscriptionARNDeserializer {
#[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 SubscriptionAttributesMapDeserializer;
impl SubscriptionAttributesMapDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<::std::collections::HashMap<String, String>, XmlParseError> {
xml_util::start_element(tag_name, stack)?;
let mut obj = ::std::collections::HashMap::new();
while xml_util::peek_at_name(stack)? == "entry" {
xml_util::start_element("entry", stack)?;
let key = AttributeNameDeserializer::deserialize("key", stack)?;
let value = AttributeValueDeserializer::deserialize("value", stack)?;
obj.insert(key, value);
xml_util::end_element("entry", stack)?;
}
xml_util::end_element(tag_name, stack)?;
Ok(obj)
}
}
struct SubscriptionAttributesMapSerializer;
impl SubscriptionAttributesMapSerializer {
fn serialize(
params: &mut Params,
name: &str,
obj: &::std::collections::HashMap<String, String>,
) {
for (index, (key, value)) in obj.iter().enumerate() {
let prefix = format!("{}.entry.{}", name, index + 1);
params.put(&format!("{}.{}", prefix, "key"), &key);
params.put(&format!("{}.{}", prefix, "value"), &value);
}
}
}
#[allow(dead_code)]
struct SubscriptionsListDeserializer;
impl SubscriptionsListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<Subscription>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "member" {
obj.push(SubscriptionDeserializer::deserialize("member", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct Tag {
pub key: String,
pub value: String,
}
#[allow(dead_code)]
struct TagDeserializer;
impl TagDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<Tag, XmlParseError> {
deserialize_elements::<_, Tag, _>(tag_name, stack, |name, stack, obj| {
match name {
"Key" => {
obj.key = TagKeyDeserializer::deserialize("Key", stack)?;
}
"Value" => {
obj.value = TagValueDeserializer::deserialize("Value", stack)?;
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
struct TagSerializer;
impl TagSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Tag) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(&format!("{}{}", prefix, "Key"), &obj.key);
params.put(&format!("{}{}", prefix, "Value"), &obj.value);
}
}
#[allow(dead_code)]
struct TagKeyDeserializer;
impl TagKeyDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
struct TagKeyListSerializer;
impl TagKeyListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<String>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.member.{}", name, index + 1);
params.put(&key, &obj);
}
}
}
#[allow(dead_code)]
struct TagListDeserializer;
impl TagListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<Tag>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "member" {
obj.push(TagDeserializer::deserialize("member", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
struct TagListSerializer;
impl TagListSerializer {
fn serialize(params: &mut Params, name: &str, obj: &Vec<Tag>) {
for (index, obj) in obj.iter().enumerate() {
let key = format!("{}.member.{}", name, index + 1);
TagSerializer::serialize(params, &key, obj);
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct TagResourceRequest {
pub resource_arn: String,
pub tags: Vec<Tag>,
}
struct TagResourceRequestSerializer;
impl TagResourceRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &TagResourceRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(&format!("{}{}", prefix, "ResourceArn"), &obj.resource_arn);
TagListSerializer::serialize(params, &format!("{}{}", prefix, "Tags"), &obj.tags);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct TagResourceResponse {}
#[allow(dead_code)]
struct TagResourceResponseDeserializer;
impl TagResourceResponseDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<TagResourceResponse, XmlParseError> {
xml_util::start_element(tag_name, stack)?;
let obj = TagResourceResponse::default();
xml_util::end_element(tag_name, stack)?;
Ok(obj)
}
}
#[allow(dead_code)]
struct TagValueDeserializer;
impl TagValueDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct Topic {
pub topic_arn: Option<String>,
}
#[allow(dead_code)]
struct TopicDeserializer;
impl TopicDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<Topic, XmlParseError> {
deserialize_elements::<_, Topic, _>(tag_name, stack, |name, stack, obj| {
match name {
"TopicArn" => {
obj.topic_arn = Some(TopicARNDeserializer::deserialize("TopicArn", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[allow(dead_code)]
struct TopicARNDeserializer;
impl TopicARNDeserializer {
#[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 TopicAttributesMapDeserializer;
impl TopicAttributesMapDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<::std::collections::HashMap<String, String>, XmlParseError> {
xml_util::start_element(tag_name, stack)?;
let mut obj = ::std::collections::HashMap::new();
while xml_util::peek_at_name(stack)? == "entry" {
xml_util::start_element("entry", stack)?;
let key = AttributeNameDeserializer::deserialize("key", stack)?;
let value = AttributeValueDeserializer::deserialize("value", stack)?;
obj.insert(key, value);
xml_util::end_element("entry", stack)?;
}
xml_util::end_element(tag_name, stack)?;
Ok(obj)
}
}
struct TopicAttributesMapSerializer;
impl TopicAttributesMapSerializer {
fn serialize(
params: &mut Params,
name: &str,
obj: &::std::collections::HashMap<String, String>,
) {
for (index, (key, value)) in obj.iter().enumerate() {
let prefix = format!("{}.entry.{}", name, index + 1);
params.put(&format!("{}.{}", prefix, "key"), &key);
params.put(&format!("{}.{}", prefix, "value"), &value);
}
}
}
#[allow(dead_code)]
struct TopicsListDeserializer;
impl TopicsListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<Topic>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "member" {
obj.push(TopicDeserializer::deserialize("member", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UnsubscribeInput {
pub subscription_arn: String,
}
struct UnsubscribeInputSerializer;
impl UnsubscribeInputSerializer {
fn serialize(params: &mut Params, name: &str, obj: &UnsubscribeInput) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(
&format!("{}{}", prefix, "SubscriptionArn"),
&obj.subscription_arn,
);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UntagResourceRequest {
pub resource_arn: String,
pub tag_keys: Vec<String>,
}
struct UntagResourceRequestSerializer;
impl UntagResourceRequestSerializer {
fn serialize(params: &mut Params, name: &str, obj: &UntagResourceRequest) {
let mut prefix = name.to_string();
if prefix != "" {
prefix.push_str(".");
}
params.put(&format!("{}{}", prefix, "ResourceArn"), &obj.resource_arn);
TagKeyListSerializer::serialize(params, &format!("{}{}", prefix, "TagKeys"), &obj.tag_keys);
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct UntagResourceResponse {}
#[allow(dead_code)]
struct UntagResourceResponseDeserializer;
impl UntagResourceResponseDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<UntagResourceResponse, XmlParseError> {
xml_util::start_element(tag_name, stack)?;
let obj = UntagResourceResponse::default();
xml_util::end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Debug, PartialEq)]
pub enum AddPermissionError {
AuthorizationError(String),
InternalError(String),
InvalidParameter(String),
NotFound(String),
}
impl AddPermissionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<AddPermissionError> {
{
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[..] {
"AuthorizationError" => {
return RusotoError::Service(AddPermissionError::AuthorizationError(
parsed_error.message,
))
}
"InternalError" => {
return RusotoError::Service(AddPermissionError::InternalError(
parsed_error.message,
))
}
"InvalidParameter" => {
return RusotoError::Service(AddPermissionError::InvalidParameter(
parsed_error.message,
))
}
"NotFound" => {
return RusotoError::Service(AddPermissionError::NotFound(
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 AddPermissionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AddPermissionError::AuthorizationError(ref cause) => write!(f, "{}", cause),
AddPermissionError::InternalError(ref cause) => write!(f, "{}", cause),
AddPermissionError::InvalidParameter(ref cause) => write!(f, "{}", cause),
AddPermissionError::NotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for AddPermissionError {}
#[derive(Debug, PartialEq)]
pub enum CheckIfPhoneNumberIsOptedOutError {
AuthorizationError(String),
InternalError(String),
InvalidParameter(String),
Throttled(String),
}
impl CheckIfPhoneNumberIsOptedOutError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<CheckIfPhoneNumberIsOptedOutError> {
{
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[..] {
"AuthorizationError" => {
return RusotoError::Service(
CheckIfPhoneNumberIsOptedOutError::AuthorizationError(
parsed_error.message,
),
)
}
"InternalError" => {
return RusotoError::Service(
CheckIfPhoneNumberIsOptedOutError::InternalError(parsed_error.message),
)
}
"InvalidParameter" => {
return RusotoError::Service(
CheckIfPhoneNumberIsOptedOutError::InvalidParameter(
parsed_error.message,
),
)
}
"Throttled" => {
return RusotoError::Service(CheckIfPhoneNumberIsOptedOutError::Throttled(
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 CheckIfPhoneNumberIsOptedOutError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CheckIfPhoneNumberIsOptedOutError::AuthorizationError(ref cause) => {
write!(f, "{}", cause)
}
CheckIfPhoneNumberIsOptedOutError::InternalError(ref cause) => write!(f, "{}", cause),
CheckIfPhoneNumberIsOptedOutError::InvalidParameter(ref cause) => {
write!(f, "{}", cause)
}
CheckIfPhoneNumberIsOptedOutError::Throttled(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CheckIfPhoneNumberIsOptedOutError {}
#[derive(Debug, PartialEq)]
pub enum ConfirmSubscriptionError {
AuthorizationError(String),
FilterPolicyLimitExceeded(String),
InternalError(String),
InvalidParameter(String),
NotFound(String),
SubscriptionLimitExceeded(String),
}
impl ConfirmSubscriptionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ConfirmSubscriptionError> {
{
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[..] {
"AuthorizationError" => {
return RusotoError::Service(ConfirmSubscriptionError::AuthorizationError(
parsed_error.message,
))
}
"FilterPolicyLimitExceeded" => {
return RusotoError::Service(
ConfirmSubscriptionError::FilterPolicyLimitExceeded(
parsed_error.message,
),
)
}
"InternalError" => {
return RusotoError::Service(ConfirmSubscriptionError::InternalError(
parsed_error.message,
))
}
"InvalidParameter" => {
return RusotoError::Service(ConfirmSubscriptionError::InvalidParameter(
parsed_error.message,
))
}
"NotFound" => {
return RusotoError::Service(ConfirmSubscriptionError::NotFound(
parsed_error.message,
))
}
"SubscriptionLimitExceeded" => {
return RusotoError::Service(
ConfirmSubscriptionError::SubscriptionLimitExceeded(
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 ConfirmSubscriptionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ConfirmSubscriptionError::AuthorizationError(ref cause) => write!(f, "{}", cause),
ConfirmSubscriptionError::FilterPolicyLimitExceeded(ref cause) => {
write!(f, "{}", cause)
}
ConfirmSubscriptionError::InternalError(ref cause) => write!(f, "{}", cause),
ConfirmSubscriptionError::InvalidParameter(ref cause) => write!(f, "{}", cause),
ConfirmSubscriptionError::NotFound(ref cause) => write!(f, "{}", cause),
ConfirmSubscriptionError::SubscriptionLimitExceeded(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for ConfirmSubscriptionError {}
#[derive(Debug, PartialEq)]
pub enum CreatePlatformApplicationError {
AuthorizationError(String),
InternalError(String),
InvalidParameter(String),
}
impl CreatePlatformApplicationError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreatePlatformApplicationError> {
{
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[..] {
"AuthorizationError" => {
return RusotoError::Service(
CreatePlatformApplicationError::AuthorizationError(
parsed_error.message,
),
)
}
"InternalError" => {
return RusotoError::Service(CreatePlatformApplicationError::InternalError(
parsed_error.message,
))
}
"InvalidParameter" => {
return RusotoError::Service(
CreatePlatformApplicationError::InvalidParameter(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 CreatePlatformApplicationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreatePlatformApplicationError::AuthorizationError(ref cause) => write!(f, "{}", cause),
CreatePlatformApplicationError::InternalError(ref cause) => write!(f, "{}", cause),
CreatePlatformApplicationError::InvalidParameter(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreatePlatformApplicationError {}
#[derive(Debug, PartialEq)]
pub enum CreatePlatformEndpointError {
AuthorizationError(String),
InternalError(String),
InvalidParameter(String),
NotFound(String),
}
impl CreatePlatformEndpointError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreatePlatformEndpointError> {
{
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[..] {
"AuthorizationError" => {
return RusotoError::Service(
CreatePlatformEndpointError::AuthorizationError(parsed_error.message),
)
}
"InternalError" => {
return RusotoError::Service(CreatePlatformEndpointError::InternalError(
parsed_error.message,
))
}
"InvalidParameter" => {
return RusotoError::Service(CreatePlatformEndpointError::InvalidParameter(
parsed_error.message,
))
}
"NotFound" => {
return RusotoError::Service(CreatePlatformEndpointError::NotFound(
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 CreatePlatformEndpointError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreatePlatformEndpointError::AuthorizationError(ref cause) => write!(f, "{}", cause),
CreatePlatformEndpointError::InternalError(ref cause) => write!(f, "{}", cause),
CreatePlatformEndpointError::InvalidParameter(ref cause) => write!(f, "{}", cause),
CreatePlatformEndpointError::NotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreatePlatformEndpointError {}
#[derive(Debug, PartialEq)]
pub enum CreateTopicError {
AuthorizationError(String),
ConcurrentAccess(String),
InternalError(String),
InvalidParameter(String),
InvalidSecurity(String),
StaleTag(String),
TagLimitExceeded(String),
TagPolicy(String),
TopicLimitExceeded(String),
}
impl CreateTopicError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateTopicError> {
{
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[..] {
"AuthorizationError" => {
return RusotoError::Service(CreateTopicError::AuthorizationError(
parsed_error.message,
))
}
"ConcurrentAccess" => {
return RusotoError::Service(CreateTopicError::ConcurrentAccess(
parsed_error.message,
))
}
"InternalError" => {
return RusotoError::Service(CreateTopicError::InternalError(
parsed_error.message,
))
}
"InvalidParameter" => {
return RusotoError::Service(CreateTopicError::InvalidParameter(
parsed_error.message,
))
}
"InvalidSecurity" => {
return RusotoError::Service(CreateTopicError::InvalidSecurity(
parsed_error.message,
))
}
"StaleTag" => {
return RusotoError::Service(CreateTopicError::StaleTag(
parsed_error.message,
))
}
"TagLimitExceeded" => {
return RusotoError::Service(CreateTopicError::TagLimitExceeded(
parsed_error.message,
))
}
"TagPolicy" => {
return RusotoError::Service(CreateTopicError::TagPolicy(
parsed_error.message,
))
}
"TopicLimitExceeded" => {
return RusotoError::Service(CreateTopicError::TopicLimitExceeded(
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 CreateTopicError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateTopicError::AuthorizationError(ref cause) => write!(f, "{}", cause),
CreateTopicError::ConcurrentAccess(ref cause) => write!(f, "{}", cause),
CreateTopicError::InternalError(ref cause) => write!(f, "{}", cause),
CreateTopicError::InvalidParameter(ref cause) => write!(f, "{}", cause),
CreateTopicError::InvalidSecurity(ref cause) => write!(f, "{}", cause),
CreateTopicError::StaleTag(ref cause) => write!(f, "{}", cause),
CreateTopicError::TagLimitExceeded(ref cause) => write!(f, "{}", cause),
CreateTopicError::TagPolicy(ref cause) => write!(f, "{}", cause),
CreateTopicError::TopicLimitExceeded(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateTopicError {}
#[derive(Debug, PartialEq)]
pub enum DeleteEndpointError {
AuthorizationError(String),
InternalError(String),
InvalidParameter(String),
}
impl DeleteEndpointError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteEndpointError> {
{
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[..] {
"AuthorizationError" => {
return RusotoError::Service(DeleteEndpointError::AuthorizationError(
parsed_error.message,
))
}
"InternalError" => {
return RusotoError::Service(DeleteEndpointError::InternalError(
parsed_error.message,
))
}
"InvalidParameter" => {
return RusotoError::Service(DeleteEndpointError::InvalidParameter(
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 DeleteEndpointError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteEndpointError::AuthorizationError(ref cause) => write!(f, "{}", cause),
DeleteEndpointError::InternalError(ref cause) => write!(f, "{}", cause),
DeleteEndpointError::InvalidParameter(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteEndpointError {}
#[derive(Debug, PartialEq)]
pub enum DeletePlatformApplicationError {
AuthorizationError(String),
InternalError(String),
InvalidParameter(String),
}
impl DeletePlatformApplicationError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeletePlatformApplicationError> {
{
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[..] {
"AuthorizationError" => {
return RusotoError::Service(
DeletePlatformApplicationError::AuthorizationError(
parsed_error.message,
),
)
}
"InternalError" => {
return RusotoError::Service(DeletePlatformApplicationError::InternalError(
parsed_error.message,
))
}
"InvalidParameter" => {
return RusotoError::Service(
DeletePlatformApplicationError::InvalidParameter(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 DeletePlatformApplicationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeletePlatformApplicationError::AuthorizationError(ref cause) => write!(f, "{}", cause),
DeletePlatformApplicationError::InternalError(ref cause) => write!(f, "{}", cause),
DeletePlatformApplicationError::InvalidParameter(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeletePlatformApplicationError {}
#[derive(Debug, PartialEq)]
pub enum DeleteTopicError {
AuthorizationError(String),
ConcurrentAccess(String),
InternalError(String),
InvalidParameter(String),
NotFound(String),
StaleTag(String),
TagPolicy(String),
}
impl DeleteTopicError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteTopicError> {
{
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[..] {
"AuthorizationError" => {
return RusotoError::Service(DeleteTopicError::AuthorizationError(
parsed_error.message,
))
}
"ConcurrentAccess" => {
return RusotoError::Service(DeleteTopicError::ConcurrentAccess(
parsed_error.message,
))
}
"InternalError" => {
return RusotoError::Service(DeleteTopicError::InternalError(
parsed_error.message,
))
}
"InvalidParameter" => {
return RusotoError::Service(DeleteTopicError::InvalidParameter(
parsed_error.message,
))
}
"NotFound" => {
return RusotoError::Service(DeleteTopicError::NotFound(
parsed_error.message,
))
}
"StaleTag" => {
return RusotoError::Service(DeleteTopicError::StaleTag(
parsed_error.message,
))
}
"TagPolicy" => {
return RusotoError::Service(DeleteTopicError::TagPolicy(
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 DeleteTopicError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteTopicError::AuthorizationError(ref cause) => write!(f, "{}", cause),
DeleteTopicError::ConcurrentAccess(ref cause) => write!(f, "{}", cause),
DeleteTopicError::InternalError(ref cause) => write!(f, "{}", cause),
DeleteTopicError::InvalidParameter(ref cause) => write!(f, "{}", cause),
DeleteTopicError::NotFound(ref cause) => write!(f, "{}", cause),
DeleteTopicError::StaleTag(ref cause) => write!(f, "{}", cause),
DeleteTopicError::TagPolicy(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteTopicError {}
#[derive(Debug, PartialEq)]
pub enum GetEndpointAttributesError {
AuthorizationError(String),
InternalError(String),
InvalidParameter(String),
NotFound(String),
}
impl GetEndpointAttributesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetEndpointAttributesError> {
{
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[..] {
"AuthorizationError" => {
return RusotoError::Service(
GetEndpointAttributesError::AuthorizationError(parsed_error.message),
)
}
"InternalError" => {
return RusotoError::Service(GetEndpointAttributesError::InternalError(
parsed_error.message,
))
}
"InvalidParameter" => {
return RusotoError::Service(GetEndpointAttributesError::InvalidParameter(
parsed_error.message,
))
}
"NotFound" => {
return RusotoError::Service(GetEndpointAttributesError::NotFound(
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 GetEndpointAttributesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetEndpointAttributesError::AuthorizationError(ref cause) => write!(f, "{}", cause),
GetEndpointAttributesError::InternalError(ref cause) => write!(f, "{}", cause),
GetEndpointAttributesError::InvalidParameter(ref cause) => write!(f, "{}", cause),
GetEndpointAttributesError::NotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetEndpointAttributesError {}
#[derive(Debug, PartialEq)]
pub enum GetPlatformApplicationAttributesError {
AuthorizationError(String),
InternalError(String),
InvalidParameter(String),
NotFound(String),
}
impl GetPlatformApplicationAttributesError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<GetPlatformApplicationAttributesError> {
{
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[..] {
"AuthorizationError" => {
return RusotoError::Service(
GetPlatformApplicationAttributesError::AuthorizationError(
parsed_error.message,
),
)
}
"InternalError" => {
return RusotoError::Service(
GetPlatformApplicationAttributesError::InternalError(
parsed_error.message,
),
)
}
"InvalidParameter" => {
return RusotoError::Service(
GetPlatformApplicationAttributesError::InvalidParameter(
parsed_error.message,
),
)
}
"NotFound" => {
return RusotoError::Service(
GetPlatformApplicationAttributesError::NotFound(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 GetPlatformApplicationAttributesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetPlatformApplicationAttributesError::AuthorizationError(ref cause) => {
write!(f, "{}", cause)
}
GetPlatformApplicationAttributesError::InternalError(ref cause) => {
write!(f, "{}", cause)
}
GetPlatformApplicationAttributesError::InvalidParameter(ref cause) => {
write!(f, "{}", cause)
}
GetPlatformApplicationAttributesError::NotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetPlatformApplicationAttributesError {}
#[derive(Debug, PartialEq)]
pub enum GetSMSAttributesError {
AuthorizationError(String),
InternalError(String),
InvalidParameter(String),
Throttled(String),
}
impl GetSMSAttributesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetSMSAttributesError> {
{
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[..] {
"AuthorizationError" => {
return RusotoError::Service(GetSMSAttributesError::AuthorizationError(
parsed_error.message,
))
}
"InternalError" => {
return RusotoError::Service(GetSMSAttributesError::InternalError(
parsed_error.message,
))
}
"InvalidParameter" => {
return RusotoError::Service(GetSMSAttributesError::InvalidParameter(
parsed_error.message,
))
}
"Throttled" => {
return RusotoError::Service(GetSMSAttributesError::Throttled(
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 GetSMSAttributesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetSMSAttributesError::AuthorizationError(ref cause) => write!(f, "{}", cause),
GetSMSAttributesError::InternalError(ref cause) => write!(f, "{}", cause),
GetSMSAttributesError::InvalidParameter(ref cause) => write!(f, "{}", cause),
GetSMSAttributesError::Throttled(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetSMSAttributesError {}
#[derive(Debug, PartialEq)]
pub enum GetSubscriptionAttributesError {
AuthorizationError(String),
InternalError(String),
InvalidParameter(String),
NotFound(String),
}
impl GetSubscriptionAttributesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetSubscriptionAttributesError> {
{
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[..] {
"AuthorizationError" => {
return RusotoError::Service(
GetSubscriptionAttributesError::AuthorizationError(
parsed_error.message,
),
)
}
"InternalError" => {
return RusotoError::Service(GetSubscriptionAttributesError::InternalError(
parsed_error.message,
))
}
"InvalidParameter" => {
return RusotoError::Service(
GetSubscriptionAttributesError::InvalidParameter(parsed_error.message),
)
}
"NotFound" => {
return RusotoError::Service(GetSubscriptionAttributesError::NotFound(
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 GetSubscriptionAttributesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetSubscriptionAttributesError::AuthorizationError(ref cause) => write!(f, "{}", cause),
GetSubscriptionAttributesError::InternalError(ref cause) => write!(f, "{}", cause),
GetSubscriptionAttributesError::InvalidParameter(ref cause) => write!(f, "{}", cause),
GetSubscriptionAttributesError::NotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetSubscriptionAttributesError {}
#[derive(Debug, PartialEq)]
pub enum GetTopicAttributesError {
AuthorizationError(String),
InternalError(String),
InvalidParameter(String),
InvalidSecurity(String),
NotFound(String),
}
impl GetTopicAttributesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetTopicAttributesError> {
{
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[..] {
"AuthorizationError" => {
return RusotoError::Service(GetTopicAttributesError::AuthorizationError(
parsed_error.message,
))
}
"InternalError" => {
return RusotoError::Service(GetTopicAttributesError::InternalError(
parsed_error.message,
))
}
"InvalidParameter" => {
return RusotoError::Service(GetTopicAttributesError::InvalidParameter(
parsed_error.message,
))
}
"InvalidSecurity" => {
return RusotoError::Service(GetTopicAttributesError::InvalidSecurity(
parsed_error.message,
))
}
"NotFound" => {
return RusotoError::Service(GetTopicAttributesError::NotFound(
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 GetTopicAttributesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetTopicAttributesError::AuthorizationError(ref cause) => write!(f, "{}", cause),
GetTopicAttributesError::InternalError(ref cause) => write!(f, "{}", cause),
GetTopicAttributesError::InvalidParameter(ref cause) => write!(f, "{}", cause),
GetTopicAttributesError::InvalidSecurity(ref cause) => write!(f, "{}", cause),
GetTopicAttributesError::NotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetTopicAttributesError {}
#[derive(Debug, PartialEq)]
pub enum ListEndpointsByPlatformApplicationError {
AuthorizationError(String),
InternalError(String),
InvalidParameter(String),
NotFound(String),
}
impl ListEndpointsByPlatformApplicationError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ListEndpointsByPlatformApplicationError> {
{
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[..] {
"AuthorizationError" => {
return RusotoError::Service(
ListEndpointsByPlatformApplicationError::AuthorizationError(
parsed_error.message,
),
)
}
"InternalError" => {
return RusotoError::Service(
ListEndpointsByPlatformApplicationError::InternalError(
parsed_error.message,
),
)
}
"InvalidParameter" => {
return RusotoError::Service(
ListEndpointsByPlatformApplicationError::InvalidParameter(
parsed_error.message,
),
)
}
"NotFound" => {
return RusotoError::Service(
ListEndpointsByPlatformApplicationError::NotFound(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 ListEndpointsByPlatformApplicationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListEndpointsByPlatformApplicationError::AuthorizationError(ref cause) => {
write!(f, "{}", cause)
}
ListEndpointsByPlatformApplicationError::InternalError(ref cause) => {
write!(f, "{}", cause)
}
ListEndpointsByPlatformApplicationError::InvalidParameter(ref cause) => {
write!(f, "{}", cause)
}
ListEndpointsByPlatformApplicationError::NotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListEndpointsByPlatformApplicationError {}
#[derive(Debug, PartialEq)]
pub enum ListPhoneNumbersOptedOutError {
AuthorizationError(String),
InternalError(String),
InvalidParameter(String),
Throttled(String),
}
impl ListPhoneNumbersOptedOutError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListPhoneNumbersOptedOutError> {
{
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[..] {
"AuthorizationError" => {
return RusotoError::Service(
ListPhoneNumbersOptedOutError::AuthorizationError(parsed_error.message),
)
}
"InternalError" => {
return RusotoError::Service(ListPhoneNumbersOptedOutError::InternalError(
parsed_error.message,
))
}
"InvalidParameter" => {
return RusotoError::Service(
ListPhoneNumbersOptedOutError::InvalidParameter(parsed_error.message),
)
}
"Throttled" => {
return RusotoError::Service(ListPhoneNumbersOptedOutError::Throttled(
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 ListPhoneNumbersOptedOutError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListPhoneNumbersOptedOutError::AuthorizationError(ref cause) => write!(f, "{}", cause),
ListPhoneNumbersOptedOutError::InternalError(ref cause) => write!(f, "{}", cause),
ListPhoneNumbersOptedOutError::InvalidParameter(ref cause) => write!(f, "{}", cause),
ListPhoneNumbersOptedOutError::Throttled(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListPhoneNumbersOptedOutError {}
#[derive(Debug, PartialEq)]
pub enum ListPlatformApplicationsError {
AuthorizationError(String),
InternalError(String),
InvalidParameter(String),
}
impl ListPlatformApplicationsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListPlatformApplicationsError> {
{
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[..] {
"AuthorizationError" => {
return RusotoError::Service(
ListPlatformApplicationsError::AuthorizationError(parsed_error.message),
)
}
"InternalError" => {
return RusotoError::Service(ListPlatformApplicationsError::InternalError(
parsed_error.message,
))
}
"InvalidParameter" => {
return RusotoError::Service(
ListPlatformApplicationsError::InvalidParameter(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 ListPlatformApplicationsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListPlatformApplicationsError::AuthorizationError(ref cause) => write!(f, "{}", cause),
ListPlatformApplicationsError::InternalError(ref cause) => write!(f, "{}", cause),
ListPlatformApplicationsError::InvalidParameter(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListPlatformApplicationsError {}
#[derive(Debug, PartialEq)]
pub enum ListSubscriptionsError {
AuthorizationError(String),
InternalError(String),
InvalidParameter(String),
}
impl ListSubscriptionsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListSubscriptionsError> {
{
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[..] {
"AuthorizationError" => {
return RusotoError::Service(ListSubscriptionsError::AuthorizationError(
parsed_error.message,
))
}
"InternalError" => {
return RusotoError::Service(ListSubscriptionsError::InternalError(
parsed_error.message,
))
}
"InvalidParameter" => {
return RusotoError::Service(ListSubscriptionsError::InvalidParameter(
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 ListSubscriptionsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListSubscriptionsError::AuthorizationError(ref cause) => write!(f, "{}", cause),
ListSubscriptionsError::InternalError(ref cause) => write!(f, "{}", cause),
ListSubscriptionsError::InvalidParameter(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListSubscriptionsError {}
#[derive(Debug, PartialEq)]
pub enum ListSubscriptionsByTopicError {
AuthorizationError(String),
InternalError(String),
InvalidParameter(String),
NotFound(String),
}
impl ListSubscriptionsByTopicError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListSubscriptionsByTopicError> {
{
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[..] {
"AuthorizationError" => {
return RusotoError::Service(
ListSubscriptionsByTopicError::AuthorizationError(parsed_error.message),
)
}
"InternalError" => {
return RusotoError::Service(ListSubscriptionsByTopicError::InternalError(
parsed_error.message,
))
}
"InvalidParameter" => {
return RusotoError::Service(
ListSubscriptionsByTopicError::InvalidParameter(parsed_error.message),
)
}
"NotFound" => {
return RusotoError::Service(ListSubscriptionsByTopicError::NotFound(
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 ListSubscriptionsByTopicError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListSubscriptionsByTopicError::AuthorizationError(ref cause) => write!(f, "{}", cause),
ListSubscriptionsByTopicError::InternalError(ref cause) => write!(f, "{}", cause),
ListSubscriptionsByTopicError::InvalidParameter(ref cause) => write!(f, "{}", cause),
ListSubscriptionsByTopicError::NotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListSubscriptionsByTopicError {}
#[derive(Debug, PartialEq)]
pub enum ListTagsForResourceError {
AuthorizationError(String),
ConcurrentAccess(String),
InvalidParameter(String),
ResourceNotFound(String),
TagPolicy(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[..] {
"AuthorizationError" => {
return RusotoError::Service(ListTagsForResourceError::AuthorizationError(
parsed_error.message,
))
}
"ConcurrentAccess" => {
return RusotoError::Service(ListTagsForResourceError::ConcurrentAccess(
parsed_error.message,
))
}
"InvalidParameter" => {
return RusotoError::Service(ListTagsForResourceError::InvalidParameter(
parsed_error.message,
))
}
"ResourceNotFound" => {
return RusotoError::Service(ListTagsForResourceError::ResourceNotFound(
parsed_error.message,
))
}
"TagPolicy" => {
return RusotoError::Service(ListTagsForResourceError::TagPolicy(
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::AuthorizationError(ref cause) => write!(f, "{}", cause),
ListTagsForResourceError::ConcurrentAccess(ref cause) => write!(f, "{}", cause),
ListTagsForResourceError::InvalidParameter(ref cause) => write!(f, "{}", cause),
ListTagsForResourceError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
ListTagsForResourceError::TagPolicy(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListTagsForResourceError {}
#[derive(Debug, PartialEq)]
pub enum ListTopicsError {
AuthorizationError(String),
InternalError(String),
InvalidParameter(String),
}
impl ListTopicsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListTopicsError> {
{
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[..] {
"AuthorizationError" => {
return RusotoError::Service(ListTopicsError::AuthorizationError(
parsed_error.message,
))
}
"InternalError" => {
return RusotoError::Service(ListTopicsError::InternalError(
parsed_error.message,
))
}
"InvalidParameter" => {
return RusotoError::Service(ListTopicsError::InvalidParameter(
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 ListTopicsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListTopicsError::AuthorizationError(ref cause) => write!(f, "{}", cause),
ListTopicsError::InternalError(ref cause) => write!(f, "{}", cause),
ListTopicsError::InvalidParameter(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListTopicsError {}
#[derive(Debug, PartialEq)]
pub enum OptInPhoneNumberError {
AuthorizationError(String),
InternalError(String),
InvalidParameter(String),
Throttled(String),
}
impl OptInPhoneNumberError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<OptInPhoneNumberError> {
{
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[..] {
"AuthorizationError" => {
return RusotoError::Service(OptInPhoneNumberError::AuthorizationError(
parsed_error.message,
))
}
"InternalError" => {
return RusotoError::Service(OptInPhoneNumberError::InternalError(
parsed_error.message,
))
}
"InvalidParameter" => {
return RusotoError::Service(OptInPhoneNumberError::InvalidParameter(
parsed_error.message,
))
}
"Throttled" => {
return RusotoError::Service(OptInPhoneNumberError::Throttled(
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 OptInPhoneNumberError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
OptInPhoneNumberError::AuthorizationError(ref cause) => write!(f, "{}", cause),
OptInPhoneNumberError::InternalError(ref cause) => write!(f, "{}", cause),
OptInPhoneNumberError::InvalidParameter(ref cause) => write!(f, "{}", cause),
OptInPhoneNumberError::Throttled(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for OptInPhoneNumberError {}
#[derive(Debug, PartialEq)]
pub enum PublishError {
AuthorizationError(String),
EndpointDisabled(String),
InternalError(String),
InvalidParameter(String),
InvalidParameterValue(String),
InvalidSecurity(String),
KMSAccessDenied(String),
KMSDisabled(String),
KMSInvalidState(String),
KMSNotFound(String),
KMSOptInRequired(String),
KMSThrottling(String),
NotFound(String),
PlatformApplicationDisabled(String),
}
impl PublishError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<PublishError> {
{
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[..] {
"AuthorizationError" => {
return RusotoError::Service(PublishError::AuthorizationError(
parsed_error.message,
))
}
"EndpointDisabled" => {
return RusotoError::Service(PublishError::EndpointDisabled(
parsed_error.message,
))
}
"InternalError" => {
return RusotoError::Service(PublishError::InternalError(
parsed_error.message,
))
}
"InvalidParameter" => {
return RusotoError::Service(PublishError::InvalidParameter(
parsed_error.message,
))
}
"ParameterValueInvalid" => {
return RusotoError::Service(PublishError::InvalidParameterValue(
parsed_error.message,
))
}
"InvalidSecurity" => {
return RusotoError::Service(PublishError::InvalidSecurity(
parsed_error.message,
))
}
"KMSAccessDenied" => {
return RusotoError::Service(PublishError::KMSAccessDenied(
parsed_error.message,
))
}
"KMSDisabled" => {
return RusotoError::Service(PublishError::KMSDisabled(
parsed_error.message,
))
}
"KMSInvalidState" => {
return RusotoError::Service(PublishError::KMSInvalidState(
parsed_error.message,
))
}
"KMSNotFound" => {
return RusotoError::Service(PublishError::KMSNotFound(
parsed_error.message,
))
}
"KMSOptInRequired" => {
return RusotoError::Service(PublishError::KMSOptInRequired(
parsed_error.message,
))
}
"KMSThrottling" => {
return RusotoError::Service(PublishError::KMSThrottling(
parsed_error.message,
))
}
"NotFound" => {
return RusotoError::Service(PublishError::NotFound(parsed_error.message))
}
"PlatformApplicationDisabled" => {
return RusotoError::Service(PublishError::PlatformApplicationDisabled(
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 PublishError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
PublishError::AuthorizationError(ref cause) => write!(f, "{}", cause),
PublishError::EndpointDisabled(ref cause) => write!(f, "{}", cause),
PublishError::InternalError(ref cause) => write!(f, "{}", cause),
PublishError::InvalidParameter(ref cause) => write!(f, "{}", cause),
PublishError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
PublishError::InvalidSecurity(ref cause) => write!(f, "{}", cause),
PublishError::KMSAccessDenied(ref cause) => write!(f, "{}", cause),
PublishError::KMSDisabled(ref cause) => write!(f, "{}", cause),
PublishError::KMSInvalidState(ref cause) => write!(f, "{}", cause),
PublishError::KMSNotFound(ref cause) => write!(f, "{}", cause),
PublishError::KMSOptInRequired(ref cause) => write!(f, "{}", cause),
PublishError::KMSThrottling(ref cause) => write!(f, "{}", cause),
PublishError::NotFound(ref cause) => write!(f, "{}", cause),
PublishError::PlatformApplicationDisabled(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for PublishError {}
#[derive(Debug, PartialEq)]
pub enum RemovePermissionError {
AuthorizationError(String),
InternalError(String),
InvalidParameter(String),
NotFound(String),
}
impl RemovePermissionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<RemovePermissionError> {
{
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[..] {
"AuthorizationError" => {
return RusotoError::Service(RemovePermissionError::AuthorizationError(
parsed_error.message,
))
}
"InternalError" => {
return RusotoError::Service(RemovePermissionError::InternalError(
parsed_error.message,
))
}
"InvalidParameter" => {
return RusotoError::Service(RemovePermissionError::InvalidParameter(
parsed_error.message,
))
}
"NotFound" => {
return RusotoError::Service(RemovePermissionError::NotFound(
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 RemovePermissionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
RemovePermissionError::AuthorizationError(ref cause) => write!(f, "{}", cause),
RemovePermissionError::InternalError(ref cause) => write!(f, "{}", cause),
RemovePermissionError::InvalidParameter(ref cause) => write!(f, "{}", cause),
RemovePermissionError::NotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for RemovePermissionError {}
#[derive(Debug, PartialEq)]
pub enum SetEndpointAttributesError {
AuthorizationError(String),
InternalError(String),
InvalidParameter(String),
NotFound(String),
}
impl SetEndpointAttributesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<SetEndpointAttributesError> {
{
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[..] {
"AuthorizationError" => {
return RusotoError::Service(
SetEndpointAttributesError::AuthorizationError(parsed_error.message),
)
}
"InternalError" => {
return RusotoError::Service(SetEndpointAttributesError::InternalError(
parsed_error.message,
))
}
"InvalidParameter" => {
return RusotoError::Service(SetEndpointAttributesError::InvalidParameter(
parsed_error.message,
))
}
"NotFound" => {
return RusotoError::Service(SetEndpointAttributesError::NotFound(
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 SetEndpointAttributesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
SetEndpointAttributesError::AuthorizationError(ref cause) => write!(f, "{}", cause),
SetEndpointAttributesError::InternalError(ref cause) => write!(f, "{}", cause),
SetEndpointAttributesError::InvalidParameter(ref cause) => write!(f, "{}", cause),
SetEndpointAttributesError::NotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for SetEndpointAttributesError {}
#[derive(Debug, PartialEq)]
pub enum SetPlatformApplicationAttributesError {
AuthorizationError(String),
InternalError(String),
InvalidParameter(String),
NotFound(String),
}
impl SetPlatformApplicationAttributesError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<SetPlatformApplicationAttributesError> {
{
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[..] {
"AuthorizationError" => {
return RusotoError::Service(
SetPlatformApplicationAttributesError::AuthorizationError(
parsed_error.message,
),
)
}
"InternalError" => {
return RusotoError::Service(
SetPlatformApplicationAttributesError::InternalError(
parsed_error.message,
),
)
}
"InvalidParameter" => {
return RusotoError::Service(
SetPlatformApplicationAttributesError::InvalidParameter(
parsed_error.message,
),
)
}
"NotFound" => {
return RusotoError::Service(
SetPlatformApplicationAttributesError::NotFound(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 SetPlatformApplicationAttributesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
SetPlatformApplicationAttributesError::AuthorizationError(ref cause) => {
write!(f, "{}", cause)
}
SetPlatformApplicationAttributesError::InternalError(ref cause) => {
write!(f, "{}", cause)
}
SetPlatformApplicationAttributesError::InvalidParameter(ref cause) => {
write!(f, "{}", cause)
}
SetPlatformApplicationAttributesError::NotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for SetPlatformApplicationAttributesError {}
#[derive(Debug, PartialEq)]
pub enum SetSMSAttributesError {
AuthorizationError(String),
InternalError(String),
InvalidParameter(String),
Throttled(String),
}
impl SetSMSAttributesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<SetSMSAttributesError> {
{
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[..] {
"AuthorizationError" => {
return RusotoError::Service(SetSMSAttributesError::AuthorizationError(
parsed_error.message,
))
}
"InternalError" => {
return RusotoError::Service(SetSMSAttributesError::InternalError(
parsed_error.message,
))
}
"InvalidParameter" => {
return RusotoError::Service(SetSMSAttributesError::InvalidParameter(
parsed_error.message,
))
}
"Throttled" => {
return RusotoError::Service(SetSMSAttributesError::Throttled(
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 SetSMSAttributesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
SetSMSAttributesError::AuthorizationError(ref cause) => write!(f, "{}", cause),
SetSMSAttributesError::InternalError(ref cause) => write!(f, "{}", cause),
SetSMSAttributesError::InvalidParameter(ref cause) => write!(f, "{}", cause),
SetSMSAttributesError::Throttled(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for SetSMSAttributesError {}
#[derive(Debug, PartialEq)]
pub enum SetSubscriptionAttributesError {
AuthorizationError(String),
FilterPolicyLimitExceeded(String),
InternalError(String),
InvalidParameter(String),
NotFound(String),
}
impl SetSubscriptionAttributesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<SetSubscriptionAttributesError> {
{
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[..] {
"AuthorizationError" => {
return RusotoError::Service(
SetSubscriptionAttributesError::AuthorizationError(
parsed_error.message,
),
)
}
"FilterPolicyLimitExceeded" => {
return RusotoError::Service(
SetSubscriptionAttributesError::FilterPolicyLimitExceeded(
parsed_error.message,
),
)
}
"InternalError" => {
return RusotoError::Service(SetSubscriptionAttributesError::InternalError(
parsed_error.message,
))
}
"InvalidParameter" => {
return RusotoError::Service(
SetSubscriptionAttributesError::InvalidParameter(parsed_error.message),
)
}
"NotFound" => {
return RusotoError::Service(SetSubscriptionAttributesError::NotFound(
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 SetSubscriptionAttributesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
SetSubscriptionAttributesError::AuthorizationError(ref cause) => write!(f, "{}", cause),
SetSubscriptionAttributesError::FilterPolicyLimitExceeded(ref cause) => {
write!(f, "{}", cause)
}
SetSubscriptionAttributesError::InternalError(ref cause) => write!(f, "{}", cause),
SetSubscriptionAttributesError::InvalidParameter(ref cause) => write!(f, "{}", cause),
SetSubscriptionAttributesError::NotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for SetSubscriptionAttributesError {}
#[derive(Debug, PartialEq)]
pub enum SetTopicAttributesError {
AuthorizationError(String),
InternalError(String),
InvalidParameter(String),
InvalidSecurity(String),
NotFound(String),
}
impl SetTopicAttributesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<SetTopicAttributesError> {
{
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[..] {
"AuthorizationError" => {
return RusotoError::Service(SetTopicAttributesError::AuthorizationError(
parsed_error.message,
))
}
"InternalError" => {
return RusotoError::Service(SetTopicAttributesError::InternalError(
parsed_error.message,
))
}
"InvalidParameter" => {
return RusotoError::Service(SetTopicAttributesError::InvalidParameter(
parsed_error.message,
))
}
"InvalidSecurity" => {
return RusotoError::Service(SetTopicAttributesError::InvalidSecurity(
parsed_error.message,
))
}
"NotFound" => {
return RusotoError::Service(SetTopicAttributesError::NotFound(
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 SetTopicAttributesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
SetTopicAttributesError::AuthorizationError(ref cause) => write!(f, "{}", cause),
SetTopicAttributesError::InternalError(ref cause) => write!(f, "{}", cause),
SetTopicAttributesError::InvalidParameter(ref cause) => write!(f, "{}", cause),
SetTopicAttributesError::InvalidSecurity(ref cause) => write!(f, "{}", cause),
SetTopicAttributesError::NotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for SetTopicAttributesError {}
#[derive(Debug, PartialEq)]
pub enum SubscribeError {
AuthorizationError(String),
FilterPolicyLimitExceeded(String),
InternalError(String),
InvalidParameter(String),
InvalidSecurity(String),
NotFound(String),
SubscriptionLimitExceeded(String),
}
impl SubscribeError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<SubscribeError> {
{
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[..] {
"AuthorizationError" => {
return RusotoError::Service(SubscribeError::AuthorizationError(
parsed_error.message,
))
}
"FilterPolicyLimitExceeded" => {
return RusotoError::Service(SubscribeError::FilterPolicyLimitExceeded(
parsed_error.message,
))
}
"InternalError" => {
return RusotoError::Service(SubscribeError::InternalError(
parsed_error.message,
))
}
"InvalidParameter" => {
return RusotoError::Service(SubscribeError::InvalidParameter(
parsed_error.message,
))
}
"InvalidSecurity" => {
return RusotoError::Service(SubscribeError::InvalidSecurity(
parsed_error.message,
))
}
"NotFound" => {
return RusotoError::Service(SubscribeError::NotFound(parsed_error.message))
}
"SubscriptionLimitExceeded" => {
return RusotoError::Service(SubscribeError::SubscriptionLimitExceeded(
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 SubscribeError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
SubscribeError::AuthorizationError(ref cause) => write!(f, "{}", cause),
SubscribeError::FilterPolicyLimitExceeded(ref cause) => write!(f, "{}", cause),
SubscribeError::InternalError(ref cause) => write!(f, "{}", cause),
SubscribeError::InvalidParameter(ref cause) => write!(f, "{}", cause),
SubscribeError::InvalidSecurity(ref cause) => write!(f, "{}", cause),
SubscribeError::NotFound(ref cause) => write!(f, "{}", cause),
SubscribeError::SubscriptionLimitExceeded(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for SubscribeError {}
#[derive(Debug, PartialEq)]
pub enum TagResourceError {
AuthorizationError(String),
ConcurrentAccess(String),
InvalidParameter(String),
ResourceNotFound(String),
StaleTag(String),
TagLimitExceeded(String),
TagPolicy(String),
}
impl TagResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<TagResourceError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"AuthorizationError" => {
return RusotoError::Service(TagResourceError::AuthorizationError(
parsed_error.message,
))
}
"ConcurrentAccess" => {
return RusotoError::Service(TagResourceError::ConcurrentAccess(
parsed_error.message,
))
}
"InvalidParameter" => {
return RusotoError::Service(TagResourceError::InvalidParameter(
parsed_error.message,
))
}
"ResourceNotFound" => {
return RusotoError::Service(TagResourceError::ResourceNotFound(
parsed_error.message,
))
}
"StaleTag" => {
return RusotoError::Service(TagResourceError::StaleTag(
parsed_error.message,
))
}
"TagLimitExceeded" => {
return RusotoError::Service(TagResourceError::TagLimitExceeded(
parsed_error.message,
))
}
"TagPolicy" => {
return RusotoError::Service(TagResourceError::TagPolicy(
parsed_error.message,
))
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for TagResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
TagResourceError::AuthorizationError(ref cause) => write!(f, "{}", cause),
TagResourceError::ConcurrentAccess(ref cause) => write!(f, "{}", cause),
TagResourceError::InvalidParameter(ref cause) => write!(f, "{}", cause),
TagResourceError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
TagResourceError::StaleTag(ref cause) => write!(f, "{}", cause),
TagResourceError::TagLimitExceeded(ref cause) => write!(f, "{}", cause),
TagResourceError::TagPolicy(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for TagResourceError {}
#[derive(Debug, PartialEq)]
pub enum UnsubscribeError {
AuthorizationError(String),
InternalError(String),
InvalidParameter(String),
InvalidSecurity(String),
NotFound(String),
}
impl UnsubscribeError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UnsubscribeError> {
{
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[..] {
"AuthorizationError" => {
return RusotoError::Service(UnsubscribeError::AuthorizationError(
parsed_error.message,
))
}
"InternalError" => {
return RusotoError::Service(UnsubscribeError::InternalError(
parsed_error.message,
))
}
"InvalidParameter" => {
return RusotoError::Service(UnsubscribeError::InvalidParameter(
parsed_error.message,
))
}
"InvalidSecurity" => {
return RusotoError::Service(UnsubscribeError::InvalidSecurity(
parsed_error.message,
))
}
"NotFound" => {
return RusotoError::Service(UnsubscribeError::NotFound(
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 UnsubscribeError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UnsubscribeError::AuthorizationError(ref cause) => write!(f, "{}", cause),
UnsubscribeError::InternalError(ref cause) => write!(f, "{}", cause),
UnsubscribeError::InvalidParameter(ref cause) => write!(f, "{}", cause),
UnsubscribeError::InvalidSecurity(ref cause) => write!(f, "{}", cause),
UnsubscribeError::NotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UnsubscribeError {}
#[derive(Debug, PartialEq)]
pub enum UntagResourceError {
AuthorizationError(String),
ConcurrentAccess(String),
InvalidParameter(String),
ResourceNotFound(String),
StaleTag(String),
TagLimitExceeded(String),
TagPolicy(String),
}
impl UntagResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UntagResourceError> {
{
let reader = EventReader::new(res.body.as_ref());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"AuthorizationError" => {
return RusotoError::Service(UntagResourceError::AuthorizationError(
parsed_error.message,
))
}
"ConcurrentAccess" => {
return RusotoError::Service(UntagResourceError::ConcurrentAccess(
parsed_error.message,
))
}
"InvalidParameter" => {
return RusotoError::Service(UntagResourceError::InvalidParameter(
parsed_error.message,
))
}
"ResourceNotFound" => {
return RusotoError::Service(UntagResourceError::ResourceNotFound(
parsed_error.message,
))
}
"StaleTag" => {
return RusotoError::Service(UntagResourceError::StaleTag(
parsed_error.message,
))
}
"TagLimitExceeded" => {
return RusotoError::Service(UntagResourceError::TagLimitExceeded(
parsed_error.message,
))
}
"TagPolicy" => {
return RusotoError::Service(UntagResourceError::TagPolicy(
parsed_error.message,
))
}
_ => {}
}
}
}
RusotoError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
xml_util::start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl fmt::Display for UntagResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UntagResourceError::AuthorizationError(ref cause) => write!(f, "{}", cause),
UntagResourceError::ConcurrentAccess(ref cause) => write!(f, "{}", cause),
UntagResourceError::InvalidParameter(ref cause) => write!(f, "{}", cause),
UntagResourceError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
UntagResourceError::StaleTag(ref cause) => write!(f, "{}", cause),
UntagResourceError::TagLimitExceeded(ref cause) => write!(f, "{}", cause),
UntagResourceError::TagPolicy(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UntagResourceError {}
#[async_trait]
pub trait Sns {
async fn add_permission(
&self,
input: AddPermissionInput,
) -> Result<(), RusotoError<AddPermissionError>>;
async fn check_if_phone_number_is_opted_out(
&self,
input: CheckIfPhoneNumberIsOptedOutInput,
) -> Result<CheckIfPhoneNumberIsOptedOutResponse, RusotoError<CheckIfPhoneNumberIsOptedOutError>>;
async fn confirm_subscription(
&self,
input: ConfirmSubscriptionInput,
) -> Result<ConfirmSubscriptionResponse, RusotoError<ConfirmSubscriptionError>>;
async fn create_platform_application(
&self,
input: CreatePlatformApplicationInput,
) -> Result<CreatePlatformApplicationResponse, RusotoError<CreatePlatformApplicationError>>;
async fn create_platform_endpoint(
&self,
input: CreatePlatformEndpointInput,
) -> Result<CreateEndpointResponse, RusotoError<CreatePlatformEndpointError>>;
async fn create_topic(
&self,
input: CreateTopicInput,
) -> Result<CreateTopicResponse, RusotoError<CreateTopicError>>;
async fn delete_endpoint(
&self,
input: DeleteEndpointInput,
) -> Result<(), RusotoError<DeleteEndpointError>>;
async fn delete_platform_application(
&self,
input: DeletePlatformApplicationInput,
) -> Result<(), RusotoError<DeletePlatformApplicationError>>;
async fn delete_topic(
&self,
input: DeleteTopicInput,
) -> Result<(), RusotoError<DeleteTopicError>>;
async fn get_endpoint_attributes(
&self,
input: GetEndpointAttributesInput,
) -> Result<GetEndpointAttributesResponse, RusotoError<GetEndpointAttributesError>>;
async fn get_platform_application_attributes(
&self,
input: GetPlatformApplicationAttributesInput,
) -> Result<
GetPlatformApplicationAttributesResponse,
RusotoError<GetPlatformApplicationAttributesError>,
>;
async fn get_sms_attributes(
&self,
input: GetSMSAttributesInput,
) -> Result<GetSMSAttributesResponse, RusotoError<GetSMSAttributesError>>;
async fn get_subscription_attributes(
&self,
input: GetSubscriptionAttributesInput,
) -> Result<GetSubscriptionAttributesResponse, RusotoError<GetSubscriptionAttributesError>>;
async fn get_topic_attributes(
&self,
input: GetTopicAttributesInput,
) -> Result<GetTopicAttributesResponse, RusotoError<GetTopicAttributesError>>;
async fn list_endpoints_by_platform_application(
&self,
input: ListEndpointsByPlatformApplicationInput,
) -> Result<
ListEndpointsByPlatformApplicationResponse,
RusotoError<ListEndpointsByPlatformApplicationError>,
>;
async fn list_phone_numbers_opted_out(
&self,
input: ListPhoneNumbersOptedOutInput,
) -> Result<ListPhoneNumbersOptedOutResponse, RusotoError<ListPhoneNumbersOptedOutError>>;
async fn list_platform_applications(
&self,
input: ListPlatformApplicationsInput,
) -> Result<ListPlatformApplicationsResponse, RusotoError<ListPlatformApplicationsError>>;
async fn list_subscriptions(
&self,
input: ListSubscriptionsInput,
) -> Result<ListSubscriptionsResponse, RusotoError<ListSubscriptionsError>>;
async fn list_subscriptions_by_topic(
&self,
input: ListSubscriptionsByTopicInput,
) -> Result<ListSubscriptionsByTopicResponse, RusotoError<ListSubscriptionsByTopicError>>;
async fn list_tags_for_resource(
&self,
input: ListTagsForResourceRequest,
) -> Result<ListTagsForResourceResponse, RusotoError<ListTagsForResourceError>>;
async fn list_topics(
&self,
input: ListTopicsInput,
) -> Result<ListTopicsResponse, RusotoError<ListTopicsError>>;
async fn opt_in_phone_number(
&self,
input: OptInPhoneNumberInput,
) -> Result<OptInPhoneNumberResponse, RusotoError<OptInPhoneNumberError>>;
async fn publish(
&self,
input: PublishInput,
) -> Result<PublishResponse, RusotoError<PublishError>>;
async fn remove_permission(
&self,
input: RemovePermissionInput,
) -> Result<(), RusotoError<RemovePermissionError>>;
async fn set_endpoint_attributes(
&self,
input: SetEndpointAttributesInput,
) -> Result<(), RusotoError<SetEndpointAttributesError>>;
async fn set_platform_application_attributes(
&self,
input: SetPlatformApplicationAttributesInput,
) -> Result<(), RusotoError<SetPlatformApplicationAttributesError>>;
async fn set_sms_attributes(
&self,
input: SetSMSAttributesInput,
) -> Result<SetSMSAttributesResponse, RusotoError<SetSMSAttributesError>>;
async fn set_subscription_attributes(
&self,
input: SetSubscriptionAttributesInput,
) -> Result<(), RusotoError<SetSubscriptionAttributesError>>;
async fn set_topic_attributes(
&self,
input: SetTopicAttributesInput,
) -> Result<(), RusotoError<SetTopicAttributesError>>;
async fn subscribe(
&self,
input: SubscribeInput,
) -> Result<SubscribeResponse, RusotoError<SubscribeError>>;
async fn tag_resource(
&self,
input: TagResourceRequest,
) -> Result<TagResourceResponse, RusotoError<TagResourceError>>;
async fn unsubscribe(
&self,
input: UnsubscribeInput,
) -> Result<(), RusotoError<UnsubscribeError>>;
async fn untag_resource(
&self,
input: UntagResourceRequest,
) -> Result<UntagResourceResponse, RusotoError<UntagResourceError>>;
}
#[derive(Clone)]
pub struct SnsClient {
client: Client,
region: region::Region,
}
impl SnsClient {
pub fn new(region: region::Region) -> SnsClient {
SnsClient {
client: Client::shared(),
region,
}
}
pub fn new_with<P, D>(
request_dispatcher: D,
credentials_provider: P,
region: region::Region,
) -> SnsClient
where
P: ProvideAwsCredentials + Send + Sync + 'static,
D: DispatchSignedRequest + Send + Sync + 'static,
{
SnsClient {
client: Client::new_with(credentials_provider, request_dispatcher),
region,
}
}
pub fn new_with_client(client: Client, region: region::Region) -> SnsClient {
SnsClient { client, region }
}
}
#[async_trait]
impl Sns for SnsClient {
async fn add_permission(
&self,
input: AddPermissionInput,
) -> Result<(), RusotoError<AddPermissionError>> {
let mut request = SignedRequest::new("POST", "sns", &self.region, "/");
let params = self.new_params("AddPermission");
let mut params = params;
AddPermissionInputSerializer::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, AddPermissionError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
async fn check_if_phone_number_is_opted_out(
&self,
input: CheckIfPhoneNumberIsOptedOutInput,
) -> Result<CheckIfPhoneNumberIsOptedOutResponse, RusotoError<CheckIfPhoneNumberIsOptedOutError>>
{
let mut request = SignedRequest::new("POST", "sns", &self.region, "/");
let params = self.new_params("CheckIfPhoneNumberIsOptedOut");
let mut params = params;
CheckIfPhoneNumberIsOptedOutInputSerializer::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, CheckIfPhoneNumberIsOptedOutError::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 = CheckIfPhoneNumberIsOptedOutResponseDeserializer::deserialize(
"CheckIfPhoneNumberIsOptedOutResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn confirm_subscription(
&self,
input: ConfirmSubscriptionInput,
) -> Result<ConfirmSubscriptionResponse, RusotoError<ConfirmSubscriptionError>> {
let mut request = SignedRequest::new("POST", "sns", &self.region, "/");
let params = self.new_params("ConfirmSubscription");
let mut params = params;
ConfirmSubscriptionInputSerializer::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, ConfirmSubscriptionError::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 = ConfirmSubscriptionResponseDeserializer::deserialize(
"ConfirmSubscriptionResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn create_platform_application(
&self,
input: CreatePlatformApplicationInput,
) -> Result<CreatePlatformApplicationResponse, RusotoError<CreatePlatformApplicationError>>
{
let mut request = SignedRequest::new("POST", "sns", &self.region, "/");
let params = self.new_params("CreatePlatformApplication");
let mut params = params;
CreatePlatformApplicationInputSerializer::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, CreatePlatformApplicationError::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 = CreatePlatformApplicationResponseDeserializer::deserialize(
"CreatePlatformApplicationResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn create_platform_endpoint(
&self,
input: CreatePlatformEndpointInput,
) -> Result<CreateEndpointResponse, RusotoError<CreatePlatformEndpointError>> {
let mut request = SignedRequest::new("POST", "sns", &self.region, "/");
let params = self.new_params("CreatePlatformEndpoint");
let mut params = params;
CreatePlatformEndpointInputSerializer::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, CreatePlatformEndpointError::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 = CreateEndpointResponseDeserializer::deserialize(
"CreatePlatformEndpointResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn create_topic(
&self,
input: CreateTopicInput,
) -> Result<CreateTopicResponse, RusotoError<CreateTopicError>> {
let mut request = SignedRequest::new("POST", "sns", &self.region, "/");
let params = self.new_params("CreateTopic");
let mut params = params;
CreateTopicInputSerializer::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, CreateTopicError::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 = CreateTopicResponseDeserializer::deserialize("CreateTopicResult", stack)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn delete_endpoint(
&self,
input: DeleteEndpointInput,
) -> Result<(), RusotoError<DeleteEndpointError>> {
let mut request = SignedRequest::new("POST", "sns", &self.region, "/");
let params = self.new_params("DeleteEndpoint");
let mut params = params;
DeleteEndpointInputSerializer::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, DeleteEndpointError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
async fn delete_platform_application(
&self,
input: DeletePlatformApplicationInput,
) -> Result<(), RusotoError<DeletePlatformApplicationError>> {
let mut request = SignedRequest::new("POST", "sns", &self.region, "/");
let params = self.new_params("DeletePlatformApplication");
let mut params = params;
DeletePlatformApplicationInputSerializer::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, DeletePlatformApplicationError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
async fn delete_topic(
&self,
input: DeleteTopicInput,
) -> Result<(), RusotoError<DeleteTopicError>> {
let mut request = SignedRequest::new("POST", "sns", &self.region, "/");
let params = self.new_params("DeleteTopic");
let mut params = params;
DeleteTopicInputSerializer::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, DeleteTopicError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
async fn get_endpoint_attributes(
&self,
input: GetEndpointAttributesInput,
) -> Result<GetEndpointAttributesResponse, RusotoError<GetEndpointAttributesError>> {
let mut request = SignedRequest::new("POST", "sns", &self.region, "/");
let params = self.new_params("GetEndpointAttributes");
let mut params = params;
GetEndpointAttributesInputSerializer::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, GetEndpointAttributesError::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 = GetEndpointAttributesResponseDeserializer::deserialize(
"GetEndpointAttributesResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn get_platform_application_attributes(
&self,
input: GetPlatformApplicationAttributesInput,
) -> Result<
GetPlatformApplicationAttributesResponse,
RusotoError<GetPlatformApplicationAttributesError>,
> {
let mut request = SignedRequest::new("POST", "sns", &self.region, "/");
let params = self.new_params("GetPlatformApplicationAttributes");
let mut params = params;
GetPlatformApplicationAttributesInputSerializer::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,
GetPlatformApplicationAttributesError::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 = GetPlatformApplicationAttributesResponseDeserializer::deserialize(
"GetPlatformApplicationAttributesResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn get_sms_attributes(
&self,
input: GetSMSAttributesInput,
) -> Result<GetSMSAttributesResponse, RusotoError<GetSMSAttributesError>> {
let mut request = SignedRequest::new("POST", "sns", &self.region, "/");
let params = self.new_params("GetSMSAttributes");
let mut params = params;
GetSMSAttributesInputSerializer::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, GetSMSAttributesError::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 =
GetSMSAttributesResponseDeserializer::deserialize("GetSMSAttributesResult", stack)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn get_subscription_attributes(
&self,
input: GetSubscriptionAttributesInput,
) -> Result<GetSubscriptionAttributesResponse, RusotoError<GetSubscriptionAttributesError>>
{
let mut request = SignedRequest::new("POST", "sns", &self.region, "/");
let params = self.new_params("GetSubscriptionAttributes");
let mut params = params;
GetSubscriptionAttributesInputSerializer::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, GetSubscriptionAttributesError::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 = GetSubscriptionAttributesResponseDeserializer::deserialize(
"GetSubscriptionAttributesResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn get_topic_attributes(
&self,
input: GetTopicAttributesInput,
) -> Result<GetTopicAttributesResponse, RusotoError<GetTopicAttributesError>> {
let mut request = SignedRequest::new("POST", "sns", &self.region, "/");
let params = self.new_params("GetTopicAttributes");
let mut params = params;
GetTopicAttributesInputSerializer::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, GetTopicAttributesError::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 = GetTopicAttributesResponseDeserializer::deserialize(
"GetTopicAttributesResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn list_endpoints_by_platform_application(
&self,
input: ListEndpointsByPlatformApplicationInput,
) -> Result<
ListEndpointsByPlatformApplicationResponse,
RusotoError<ListEndpointsByPlatformApplicationError>,
> {
let mut request = SignedRequest::new("POST", "sns", &self.region, "/");
let params = self.new_params("ListEndpointsByPlatformApplication");
let mut params = params;
ListEndpointsByPlatformApplicationInputSerializer::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,
ListEndpointsByPlatformApplicationError::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 = ListEndpointsByPlatformApplicationResponseDeserializer::deserialize(
"ListEndpointsByPlatformApplicationResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn list_phone_numbers_opted_out(
&self,
input: ListPhoneNumbersOptedOutInput,
) -> Result<ListPhoneNumbersOptedOutResponse, RusotoError<ListPhoneNumbersOptedOutError>> {
let mut request = SignedRequest::new("POST", "sns", &self.region, "/");
let params = self.new_params("ListPhoneNumbersOptedOut");
let mut params = params;
ListPhoneNumbersOptedOutInputSerializer::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, ListPhoneNumbersOptedOutError::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 = ListPhoneNumbersOptedOutResponseDeserializer::deserialize(
"ListPhoneNumbersOptedOutResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn list_platform_applications(
&self,
input: ListPlatformApplicationsInput,
) -> Result<ListPlatformApplicationsResponse, RusotoError<ListPlatformApplicationsError>> {
let mut request = SignedRequest::new("POST", "sns", &self.region, "/");
let params = self.new_params("ListPlatformApplications");
let mut params = params;
ListPlatformApplicationsInputSerializer::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, ListPlatformApplicationsError::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 = ListPlatformApplicationsResponseDeserializer::deserialize(
"ListPlatformApplicationsResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn list_subscriptions(
&self,
input: ListSubscriptionsInput,
) -> Result<ListSubscriptionsResponse, RusotoError<ListSubscriptionsError>> {
let mut request = SignedRequest::new("POST", "sns", &self.region, "/");
let params = self.new_params("ListSubscriptions");
let mut params = params;
ListSubscriptionsInputSerializer::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, ListSubscriptionsError::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 = ListSubscriptionsResponseDeserializer::deserialize(
"ListSubscriptionsResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn list_subscriptions_by_topic(
&self,
input: ListSubscriptionsByTopicInput,
) -> Result<ListSubscriptionsByTopicResponse, RusotoError<ListSubscriptionsByTopicError>> {
let mut request = SignedRequest::new("POST", "sns", &self.region, "/");
let params = self.new_params("ListSubscriptionsByTopic");
let mut params = params;
ListSubscriptionsByTopicInputSerializer::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, ListSubscriptionsByTopicError::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 = ListSubscriptionsByTopicResponseDeserializer::deserialize(
"ListSubscriptionsByTopicResult",
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: ListTagsForResourceRequest,
) -> Result<ListTagsForResourceResponse, RusotoError<ListTagsForResourceError>> {
let mut request = SignedRequest::new("POST", "sns", &self.region, "/");
let params = self.new_params("ListTagsForResource");
let mut params = params;
ListTagsForResourceRequestSerializer::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 = ListTagsForResourceResponseDeserializer::deserialize(
"ListTagsForResourceResult",
stack,
)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn list_topics(
&self,
input: ListTopicsInput,
) -> Result<ListTopicsResponse, RusotoError<ListTopicsError>> {
let mut request = SignedRequest::new("POST", "sns", &self.region, "/");
let params = self.new_params("ListTopics");
let mut params = params;
ListTopicsInputSerializer::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, ListTopicsError::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 = ListTopicsResponseDeserializer::deserialize("ListTopicsResult", stack)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn opt_in_phone_number(
&self,
input: OptInPhoneNumberInput,
) -> Result<OptInPhoneNumberResponse, RusotoError<OptInPhoneNumberError>> {
let mut request = SignedRequest::new("POST", "sns", &self.region, "/");
let params = self.new_params("OptInPhoneNumber");
let mut params = params;
OptInPhoneNumberInputSerializer::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, OptInPhoneNumberError::from_response)
.await?;
let result = OptInPhoneNumberResponse::default();
drop(response);
Ok(result)
}
async fn publish(
&self,
input: PublishInput,
) -> Result<PublishResponse, RusotoError<PublishError>> {
let mut request = SignedRequest::new("POST", "sns", &self.region, "/");
let params = self.new_params("Publish");
let mut params = params;
PublishInputSerializer::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, PublishError::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 = PublishResponseDeserializer::deserialize("PublishResult", stack)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn remove_permission(
&self,
input: RemovePermissionInput,
) -> Result<(), RusotoError<RemovePermissionError>> {
let mut request = SignedRequest::new("POST", "sns", &self.region, "/");
let params = self.new_params("RemovePermission");
let mut params = params;
RemovePermissionInputSerializer::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, RemovePermissionError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
async fn set_endpoint_attributes(
&self,
input: SetEndpointAttributesInput,
) -> Result<(), RusotoError<SetEndpointAttributesError>> {
let mut request = SignedRequest::new("POST", "sns", &self.region, "/");
let params = self.new_params("SetEndpointAttributes");
let mut params = params;
SetEndpointAttributesInputSerializer::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, SetEndpointAttributesError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
async fn set_platform_application_attributes(
&self,
input: SetPlatformApplicationAttributesInput,
) -> Result<(), RusotoError<SetPlatformApplicationAttributesError>> {
let mut request = SignedRequest::new("POST", "sns", &self.region, "/");
let params = self.new_params("SetPlatformApplicationAttributes");
let mut params = params;
SetPlatformApplicationAttributesInputSerializer::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,
SetPlatformApplicationAttributesError::from_response,
)
.await?;
std::mem::drop(response);
Ok(())
}
async fn set_sms_attributes(
&self,
input: SetSMSAttributesInput,
) -> Result<SetSMSAttributesResponse, RusotoError<SetSMSAttributesError>> {
let mut request = SignedRequest::new("POST", "sns", &self.region, "/");
let params = self.new_params("SetSMSAttributes");
let mut params = params;
SetSMSAttributesInputSerializer::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, SetSMSAttributesError::from_response)
.await?;
let result = SetSMSAttributesResponse::default();
drop(response);
Ok(result)
}
async fn set_subscription_attributes(
&self,
input: SetSubscriptionAttributesInput,
) -> Result<(), RusotoError<SetSubscriptionAttributesError>> {
let mut request = SignedRequest::new("POST", "sns", &self.region, "/");
let params = self.new_params("SetSubscriptionAttributes");
let mut params = params;
SetSubscriptionAttributesInputSerializer::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, SetSubscriptionAttributesError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
async fn set_topic_attributes(
&self,
input: SetTopicAttributesInput,
) -> Result<(), RusotoError<SetTopicAttributesError>> {
let mut request = SignedRequest::new("POST", "sns", &self.region, "/");
let params = self.new_params("SetTopicAttributes");
let mut params = params;
SetTopicAttributesInputSerializer::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, SetTopicAttributesError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
async fn subscribe(
&self,
input: SubscribeInput,
) -> Result<SubscribeResponse, RusotoError<SubscribeError>> {
let mut request = SignedRequest::new("POST", "sns", &self.region, "/");
let params = self.new_params("Subscribe");
let mut params = params;
SubscribeInputSerializer::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, SubscribeError::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 = SubscribeResponseDeserializer::deserialize("SubscribeResult", stack)?;
skip_tree(stack);
xml_util::end_element(actual_tag_name, stack)?;
Ok(result)
})
.await?;
drop(response);
Ok(result)
}
async fn tag_resource(
&self,
input: TagResourceRequest,
) -> Result<TagResourceResponse, RusotoError<TagResourceError>> {
let mut request = SignedRequest::new("POST", "sns", &self.region, "/");
let params = self.new_params("TagResource");
let mut params = params;
TagResourceRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, TagResourceError::from_response)
.await?;
let result = TagResourceResponse::default();
drop(response);
Ok(result)
}
async fn unsubscribe(
&self,
input: UnsubscribeInput,
) -> Result<(), RusotoError<UnsubscribeError>> {
let mut request = SignedRequest::new("POST", "sns", &self.region, "/");
let params = self.new_params("Unsubscribe");
let mut params = params;
UnsubscribeInputSerializer::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, UnsubscribeError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
async fn untag_resource(
&self,
input: UntagResourceRequest,
) -> Result<UntagResourceResponse, RusotoError<UntagResourceError>> {
let mut request = SignedRequest::new("POST", "sns", &self.region, "/");
let params = self.new_params("UntagResource");
let mut params = params;
UntagResourceRequestSerializer::serialize(&mut params, "", &input);
request.set_payload(Some(serde_urlencoded::to_string(¶ms).unwrap()));
request.set_content_type("application/x-www-form-urlencoded".to_owned());
let response = self
.sign_and_dispatch(request, UntagResourceError::from_response)
.await?;
let result = UntagResourceResponse::default();
drop(response);
Ok(result)
}
}
#[cfg(test)]
mod protocol_tests {
extern crate rusoto_mock;
use self::rusoto_mock::*;
use super::*;
use rusoto_core::Region as rusoto_region;
#[tokio::test]
async fn test_parse_error_sns_delete_topic() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/error",
"sns-delete-topic.xml",
);
let mock = MockRequestDispatcher::with_status(400).with_body(&mock_response);
let client = SnsClient::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = DeleteTopicInput::default();
let result = client.delete_topic(request).await;
assert!(!result.is_ok(), "parse error: {:?}", result);
}
#[tokio::test]
async fn test_parse_valid_sns_add_permission() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"sns-add-permission.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client = SnsClient::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = AddPermissionInput::default();
let result = client.add_permission(request).await;
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[tokio::test]
async fn test_parse_valid_sns_confirm_subscription() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"sns-confirm-subscription.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client = SnsClient::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = ConfirmSubscriptionInput::default();
let result = client.confirm_subscription(request).await;
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[tokio::test]
async fn test_parse_valid_sns_create_topic() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"sns-create-topic.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client = SnsClient::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = CreateTopicInput::default();
let result = client.create_topic(request).await;
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[tokio::test]
async fn test_parse_valid_sns_get_subscription_attributes() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"sns-get-subscription-attributes.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client = SnsClient::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = GetSubscriptionAttributesInput::default();
let result = client.get_subscription_attributes(request).await;
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[tokio::test]
async fn test_parse_valid_sns_get_topic_attributes() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"sns-get-topic-attributes.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client = SnsClient::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = GetTopicAttributesInput::default();
let result = client.get_topic_attributes(request).await;
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[tokio::test]
async fn test_parse_valid_sns_list_subscriptions_by_topic() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"sns-list-subscriptions-by-topic.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client = SnsClient::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = ListSubscriptionsByTopicInput::default();
let result = client.list_subscriptions_by_topic(request).await;
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[tokio::test]
async fn test_parse_valid_sns_list_subscriptions() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"sns-list-subscriptions.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client = SnsClient::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = ListSubscriptionsInput::default();
let result = client.list_subscriptions(request).await;
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[tokio::test]
async fn test_parse_valid_sns_list_topics() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"sns-list-topics.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client = SnsClient::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = ListTopicsInput::default();
let result = client.list_topics(request).await;
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[tokio::test]
async fn test_parse_valid_sns_publish() {
let mock_response =
MockResponseReader::read_response("test_resources/generated/valid", "sns-publish.xml");
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client = SnsClient::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = PublishInput::default();
let result = client.publish(request).await;
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[tokio::test]
async fn test_parse_valid_sns_subscribe() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"sns-subscribe.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client = SnsClient::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = SubscribeInput::default();
let result = client.subscribe(request).await;
assert!(result.is_ok(), "parse error: {:?}", result);
}
}