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, write_characters_element,
};
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 std::io::Write;
use std::str::FromStr;
use xml;
use xml::EventReader;
use xml::EventWriter;
impl CloudFrontClient {
async fn sign_and_dispatch<E>(
&self,
request: SignedRequest,
from_response: fn(BufferedHttpResponse) -> RusotoError<E>,
) -> Result<HttpResponse, RusotoError<E>> {
let mut response = self.client.sign_and_dispatch(request).await?;
if !response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
return Err(from_response(response));
}
Ok(response)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct ActiveTrustedSigners {
pub enabled: bool,
pub items: Option<Vec<Signer>>,
pub quantity: i64,
}
#[allow(dead_code)]
struct ActiveTrustedSignersDeserializer;
impl ActiveTrustedSignersDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ActiveTrustedSigners, XmlParseError> {
deserialize_elements::<_, ActiveTrustedSigners, _>(tag_name, stack, |name, stack, obj| {
match name {
"Enabled" => {
obj.enabled = BooleanDeserializer::deserialize("Enabled", stack)?;
}
"Items" => {
obj.items
.get_or_insert(vec![])
.extend(SignerListDeserializer::deserialize("Items", stack)?);
}
"Quantity" => {
obj.quantity = IntegerDeserializer::deserialize("Quantity", stack)?;
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct AliasICPRecordal {
pub cname: Option<String>,
pub icp_recordal_status: Option<String>,
}
#[allow(dead_code)]
struct AliasICPRecordalDeserializer;
impl AliasICPRecordalDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<AliasICPRecordal, XmlParseError> {
deserialize_elements::<_, AliasICPRecordal, _>(tag_name, stack, |name, stack, obj| {
match name {
"CNAME" => {
obj.cname = Some(StringDeserializer::deserialize("CNAME", stack)?);
}
"ICPRecordalStatus" => {
obj.icp_recordal_status = Some(ICPRecordalStatusDeserializer::deserialize(
"ICPRecordalStatus",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[allow(dead_code)]
struct AliasICPRecordalsDeserializer;
impl AliasICPRecordalsDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<AliasICPRecordal>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "AliasICPRecordal" {
obj.push(AliasICPRecordalDeserializer::deserialize(
"AliasICPRecordal",
stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[allow(dead_code)]
struct AliasListDeserializer;
impl AliasListDeserializer {
#[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 == "CNAME" {
obj.push(StringDeserializer::deserialize("CNAME", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
pub struct AliasListSerializer;
impl AliasListSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &Vec<String>,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
for element in obj {
StringSerializer::serialize(writer, "CNAME", element)?;
}
writer.write(xml::writer::XmlEvent::end_element())?;
Ok(())
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct Aliases {
pub items: Option<Vec<String>>,
pub quantity: i64,
}
#[allow(dead_code)]
struct AliasesDeserializer;
impl AliasesDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Aliases, XmlParseError> {
deserialize_elements::<_, Aliases, _>(tag_name, stack, |name, stack, obj| {
match name {
"Items" => {
obj.items
.get_or_insert(vec![])
.extend(AliasListDeserializer::deserialize("Items", stack)?);
}
"Quantity" => {
obj.quantity = IntegerDeserializer::deserialize("Quantity", stack)?;
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
pub struct AliasesSerializer;
impl AliasesSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &Aliases,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
if let Some(ref value) = obj.items {
&AliasListSerializer::serialize(&mut writer, "Items", value)?;
}
write_characters_element(writer, "Quantity", &obj.quantity.to_string())?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AllowedMethods {
pub cached_methods: Option<CachedMethods>,
pub items: Vec<String>,
pub quantity: i64,
}
#[allow(dead_code)]
struct AllowedMethodsDeserializer;
impl AllowedMethodsDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<AllowedMethods, XmlParseError> {
deserialize_elements::<_, AllowedMethods, _>(tag_name, stack, |name, stack, obj| {
match name {
"CachedMethods" => {
obj.cached_methods = Some(CachedMethodsDeserializer::deserialize(
"CachedMethods",
stack,
)?);
}
"Items" => {
obj.items
.extend(MethodsListDeserializer::deserialize("Items", stack)?);
}
"Quantity" => {
obj.quantity = IntegerDeserializer::deserialize("Quantity", stack)?;
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
pub struct AllowedMethodsSerializer;
impl AllowedMethodsSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &AllowedMethods,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
if let Some(ref value) = obj.cached_methods {
&CachedMethodsSerializer::serialize(&mut writer, "CachedMethods", value)?;
}
MethodsListSerializer::serialize(&mut writer, "Items", &obj.items)?;
write_characters_element(writer, "Quantity", &obj.quantity.to_string())?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[allow(dead_code)]
struct AwsAccountNumberListDeserializer;
impl AwsAccountNumberListDeserializer {
#[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 == "AwsAccountNumber" {
obj.push(StringDeserializer::deserialize("AwsAccountNumber", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
pub struct AwsAccountNumberListSerializer;
impl AwsAccountNumberListSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &Vec<String>,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
for element in obj {
StringSerializer::serialize(writer, "AwsAccountNumber", element)?;
}
writer.write(xml::writer::XmlEvent::end_element())?;
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()))
}
}
pub struct BooleanSerializer;
impl BooleanSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &bool,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
write_characters_element(writer, name, &obj.to_string())
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CacheBehavior {
pub allowed_methods: Option<AllowedMethods>,
pub compress: Option<bool>,
pub default_ttl: Option<i64>,
pub field_level_encryption_id: Option<String>,
pub forwarded_values: ForwardedValues,
pub lambda_function_associations: Option<LambdaFunctionAssociations>,
pub max_ttl: Option<i64>,
pub min_ttl: i64,
pub path_pattern: String,
pub smooth_streaming: Option<bool>,
pub target_origin_id: String,
pub trusted_signers: TrustedSigners,
pub viewer_protocol_policy: String,
}
#[allow(dead_code)]
struct CacheBehaviorDeserializer;
impl CacheBehaviorDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CacheBehavior, XmlParseError> {
deserialize_elements::<_, CacheBehavior, _>(tag_name, stack, |name, stack, obj| {
match name {
"AllowedMethods" => {
obj.allowed_methods = Some(AllowedMethodsDeserializer::deserialize(
"AllowedMethods",
stack,
)?);
}
"Compress" => {
obj.compress = Some(BooleanDeserializer::deserialize("Compress", stack)?);
}
"DefaultTTL" => {
obj.default_ttl = Some(LongDeserializer::deserialize("DefaultTTL", stack)?);
}
"FieldLevelEncryptionId" => {
obj.field_level_encryption_id = Some(StringDeserializer::deserialize(
"FieldLevelEncryptionId",
stack,
)?);
}
"ForwardedValues" => {
obj.forwarded_values =
ForwardedValuesDeserializer::deserialize("ForwardedValues", stack)?;
}
"LambdaFunctionAssociations" => {
obj.lambda_function_associations =
Some(LambdaFunctionAssociationsDeserializer::deserialize(
"LambdaFunctionAssociations",
stack,
)?);
}
"MaxTTL" => {
obj.max_ttl = Some(LongDeserializer::deserialize("MaxTTL", stack)?);
}
"MinTTL" => {
obj.min_ttl = LongDeserializer::deserialize("MinTTL", stack)?;
}
"PathPattern" => {
obj.path_pattern = StringDeserializer::deserialize("PathPattern", stack)?;
}
"SmoothStreaming" => {
obj.smooth_streaming =
Some(BooleanDeserializer::deserialize("SmoothStreaming", stack)?);
}
"TargetOriginId" => {
obj.target_origin_id =
StringDeserializer::deserialize("TargetOriginId", stack)?;
}
"TrustedSigners" => {
obj.trusted_signers =
TrustedSignersDeserializer::deserialize("TrustedSigners", stack)?;
}
"ViewerProtocolPolicy" => {
obj.viewer_protocol_policy = ViewerProtocolPolicyDeserializer::deserialize(
"ViewerProtocolPolicy",
stack,
)?;
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
pub struct CacheBehaviorSerializer;
impl CacheBehaviorSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &CacheBehavior,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
if let Some(ref value) = obj.allowed_methods {
&AllowedMethodsSerializer::serialize(&mut writer, "AllowedMethods", value)?;
}
if let Some(ref value) = obj.compress {
write_characters_element(writer, "Compress", &value.to_string())?;
}
if let Some(ref value) = obj.default_ttl {
write_characters_element(writer, "DefaultTTL", &value.to_string())?;
}
if let Some(ref value) = obj.field_level_encryption_id {
write_characters_element(writer, "FieldLevelEncryptionId", &value.to_string())?;
}
ForwardedValuesSerializer::serialize(
&mut writer,
"ForwardedValues",
&obj.forwarded_values,
)?;
if let Some(ref value) = obj.lambda_function_associations {
&LambdaFunctionAssociationsSerializer::serialize(
&mut writer,
"LambdaFunctionAssociations",
value,
)?;
}
if let Some(ref value) = obj.max_ttl {
write_characters_element(writer, "MaxTTL", &value.to_string())?;
}
write_characters_element(writer, "MinTTL", &obj.min_ttl.to_string())?;
write_characters_element(writer, "PathPattern", &obj.path_pattern.to_string())?;
if let Some(ref value) = obj.smooth_streaming {
write_characters_element(writer, "SmoothStreaming", &value.to_string())?;
}
write_characters_element(writer, "TargetOriginId", &obj.target_origin_id.to_string())?;
TrustedSignersSerializer::serialize(&mut writer, "TrustedSigners", &obj.trusted_signers)?;
write_characters_element(
writer,
"ViewerProtocolPolicy",
&obj.viewer_protocol_policy.to_string(),
)?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[allow(dead_code)]
struct CacheBehaviorListDeserializer;
impl CacheBehaviorListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<CacheBehavior>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "CacheBehavior" {
obj.push(CacheBehaviorDeserializer::deserialize(
"CacheBehavior",
stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
pub struct CacheBehaviorListSerializer;
impl CacheBehaviorListSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &Vec<CacheBehavior>,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
for element in obj {
CacheBehaviorSerializer::serialize(writer, "CacheBehavior", element)?;
}
writer.write(xml::writer::XmlEvent::end_element())?;
Ok(())
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CacheBehaviors {
pub items: Option<Vec<CacheBehavior>>,
pub quantity: i64,
}
#[allow(dead_code)]
struct CacheBehaviorsDeserializer;
impl CacheBehaviorsDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CacheBehaviors, XmlParseError> {
deserialize_elements::<_, CacheBehaviors, _>(tag_name, stack, |name, stack, obj| {
match name {
"Items" => {
obj.items
.get_or_insert(vec![])
.extend(CacheBehaviorListDeserializer::deserialize("Items", stack)?);
}
"Quantity" => {
obj.quantity = IntegerDeserializer::deserialize("Quantity", stack)?;
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
pub struct CacheBehaviorsSerializer;
impl CacheBehaviorsSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &CacheBehaviors,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
if let Some(ref value) = obj.items {
&CacheBehaviorListSerializer::serialize(&mut writer, "Items", value)?;
}
write_characters_element(writer, "Quantity", &obj.quantity.to_string())?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CachedMethods {
pub items: Vec<String>,
pub quantity: i64,
}
#[allow(dead_code)]
struct CachedMethodsDeserializer;
impl CachedMethodsDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CachedMethods, XmlParseError> {
deserialize_elements::<_, CachedMethods, _>(tag_name, stack, |name, stack, obj| {
match name {
"Items" => {
obj.items
.extend(MethodsListDeserializer::deserialize("Items", stack)?);
}
"Quantity" => {
obj.quantity = IntegerDeserializer::deserialize("Quantity", stack)?;
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
pub struct CachedMethodsSerializer;
impl CachedMethodsSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &CachedMethods,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
MethodsListSerializer::serialize(&mut writer, "Items", &obj.items)?;
write_characters_element(writer, "Quantity", &obj.quantity.to_string())?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct CloudFrontOriginAccessIdentity {
pub cloud_front_origin_access_identity_config: Option<CloudFrontOriginAccessIdentityConfig>,
pub id: String,
pub s3_canonical_user_id: String,
}
#[allow(dead_code)]
struct CloudFrontOriginAccessIdentityDeserializer;
impl CloudFrontOriginAccessIdentityDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CloudFrontOriginAccessIdentity, XmlParseError> {
deserialize_elements::<_, CloudFrontOriginAccessIdentity, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"CloudFrontOriginAccessIdentityConfig" => {
obj.cloud_front_origin_access_identity_config = Some(
CloudFrontOriginAccessIdentityConfigDeserializer::deserialize(
"CloudFrontOriginAccessIdentityConfig",
stack,
)?,
);
}
"Id" => {
obj.id = StringDeserializer::deserialize("Id", stack)?;
}
"S3CanonicalUserId" => {
obj.s3_canonical_user_id =
StringDeserializer::deserialize("S3CanonicalUserId", stack)?;
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CloudFrontOriginAccessIdentityConfig {
pub caller_reference: String,
pub comment: String,
}
#[allow(dead_code)]
struct CloudFrontOriginAccessIdentityConfigDeserializer;
impl CloudFrontOriginAccessIdentityConfigDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CloudFrontOriginAccessIdentityConfig, XmlParseError> {
deserialize_elements::<_, CloudFrontOriginAccessIdentityConfig, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"CallerReference" => {
obj.caller_reference =
StringDeserializer::deserialize("CallerReference", stack)?;
}
"Comment" => {
obj.comment = StringDeserializer::deserialize("Comment", stack)?;
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
pub struct CloudFrontOriginAccessIdentityConfigSerializer;
impl CloudFrontOriginAccessIdentityConfigSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &CloudFrontOriginAccessIdentityConfig,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
write_characters_element(writer, "CallerReference", &obj.caller_reference.to_string())?;
write_characters_element(writer, "Comment", &obj.comment.to_string())?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct CloudFrontOriginAccessIdentityList {
pub is_truncated: bool,
pub items: Option<Vec<CloudFrontOriginAccessIdentitySummary>>,
pub marker: String,
pub max_items: i64,
pub next_marker: Option<String>,
pub quantity: i64,
}
#[allow(dead_code)]
struct CloudFrontOriginAccessIdentityListDeserializer;
impl CloudFrontOriginAccessIdentityListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CloudFrontOriginAccessIdentityList, XmlParseError> {
deserialize_elements::<_, CloudFrontOriginAccessIdentityList, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"IsTruncated" => {
obj.is_truncated = BooleanDeserializer::deserialize("IsTruncated", stack)?;
}
"Items" => {
obj.items.get_or_insert(vec![]).extend(
CloudFrontOriginAccessIdentitySummaryListDeserializer::deserialize(
"Items", stack,
)?,
);
}
"Marker" => {
obj.marker = StringDeserializer::deserialize("Marker", stack)?;
}
"MaxItems" => {
obj.max_items = IntegerDeserializer::deserialize("MaxItems", stack)?;
}
"NextMarker" => {
obj.next_marker =
Some(StringDeserializer::deserialize("NextMarker", stack)?);
}
"Quantity" => {
obj.quantity = IntegerDeserializer::deserialize("Quantity", stack)?;
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct CloudFrontOriginAccessIdentitySummary {
pub comment: String,
pub id: String,
pub s3_canonical_user_id: String,
}
#[allow(dead_code)]
struct CloudFrontOriginAccessIdentitySummaryDeserializer;
impl CloudFrontOriginAccessIdentitySummaryDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CloudFrontOriginAccessIdentitySummary, XmlParseError> {
deserialize_elements::<_, CloudFrontOriginAccessIdentitySummary, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"Comment" => {
obj.comment = StringDeserializer::deserialize("Comment", stack)?;
}
"Id" => {
obj.id = StringDeserializer::deserialize("Id", stack)?;
}
"S3CanonicalUserId" => {
obj.s3_canonical_user_id =
StringDeserializer::deserialize("S3CanonicalUserId", stack)?;
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[allow(dead_code)]
struct CloudFrontOriginAccessIdentitySummaryListDeserializer;
impl CloudFrontOriginAccessIdentitySummaryListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<CloudFrontOriginAccessIdentitySummary>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "CloudFrontOriginAccessIdentitySummary" {
obj.push(
CloudFrontOriginAccessIdentitySummaryDeserializer::deserialize(
"CloudFrontOriginAccessIdentitySummary",
stack,
)?,
);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[allow(dead_code)]
struct CommentTypeDeserializer;
impl CommentTypeDeserializer {
#[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)
}
}
pub struct CommentTypeSerializer;
impl CommentTypeSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &String,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
write_characters_element(writer, name, obj)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ContentTypeProfile {
pub content_type: String,
pub format: String,
pub profile_id: Option<String>,
}
#[allow(dead_code)]
struct ContentTypeProfileDeserializer;
impl ContentTypeProfileDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ContentTypeProfile, XmlParseError> {
deserialize_elements::<_, ContentTypeProfile, _>(tag_name, stack, |name, stack, obj| {
match name {
"ContentType" => {
obj.content_type = StringDeserializer::deserialize("ContentType", stack)?;
}
"Format" => {
obj.format = FormatDeserializer::deserialize("Format", stack)?;
}
"ProfileId" => {
obj.profile_id = Some(StringDeserializer::deserialize("ProfileId", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
pub struct ContentTypeProfileSerializer;
impl ContentTypeProfileSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &ContentTypeProfile,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
write_characters_element(writer, "ContentType", &obj.content_type.to_string())?;
write_characters_element(writer, "Format", &obj.format.to_string())?;
if let Some(ref value) = obj.profile_id {
write_characters_element(writer, "ProfileId", &value.to_string())?;
}
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ContentTypeProfileConfig {
pub content_type_profiles: Option<ContentTypeProfiles>,
pub forward_when_content_type_is_unknown: bool,
}
#[allow(dead_code)]
struct ContentTypeProfileConfigDeserializer;
impl ContentTypeProfileConfigDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ContentTypeProfileConfig, XmlParseError> {
deserialize_elements::<_, ContentTypeProfileConfig, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"ContentTypeProfiles" => {
obj.content_type_profiles =
Some(ContentTypeProfilesDeserializer::deserialize(
"ContentTypeProfiles",
stack,
)?);
}
"ForwardWhenContentTypeIsUnknown" => {
obj.forward_when_content_type_is_unknown =
BooleanDeserializer::deserialize(
"ForwardWhenContentTypeIsUnknown",
stack,
)?;
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
pub struct ContentTypeProfileConfigSerializer;
impl ContentTypeProfileConfigSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &ContentTypeProfileConfig,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
if let Some(ref value) = obj.content_type_profiles {
&ContentTypeProfilesSerializer::serialize(&mut writer, "ContentTypeProfiles", value)?;
}
write_characters_element(
writer,
"ForwardWhenContentTypeIsUnknown",
&obj.forward_when_content_type_is_unknown.to_string(),
)?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[allow(dead_code)]
struct ContentTypeProfileListDeserializer;
impl ContentTypeProfileListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<ContentTypeProfile>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "ContentTypeProfile" {
obj.push(ContentTypeProfileDeserializer::deserialize(
"ContentTypeProfile",
stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
pub struct ContentTypeProfileListSerializer;
impl ContentTypeProfileListSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &Vec<ContentTypeProfile>,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
for element in obj {
ContentTypeProfileSerializer::serialize(writer, "ContentTypeProfile", element)?;
}
writer.write(xml::writer::XmlEvent::end_element())?;
Ok(())
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ContentTypeProfiles {
pub items: Option<Vec<ContentTypeProfile>>,
pub quantity: i64,
}
#[allow(dead_code)]
struct ContentTypeProfilesDeserializer;
impl ContentTypeProfilesDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ContentTypeProfiles, XmlParseError> {
deserialize_elements::<_, ContentTypeProfiles, _>(tag_name, stack, |name, stack, obj| {
match name {
"Items" => {
obj.items.get_or_insert(vec![]).extend(
ContentTypeProfileListDeserializer::deserialize("Items", stack)?,
);
}
"Quantity" => {
obj.quantity = IntegerDeserializer::deserialize("Quantity", stack)?;
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
pub struct ContentTypeProfilesSerializer;
impl ContentTypeProfilesSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &ContentTypeProfiles,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
if let Some(ref value) = obj.items {
&ContentTypeProfileListSerializer::serialize(&mut writer, "Items", value)?;
}
write_characters_element(writer, "Quantity", &obj.quantity.to_string())?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[allow(dead_code)]
struct CookieNameListDeserializer;
impl CookieNameListDeserializer {
#[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 == "Name" {
obj.push(StringDeserializer::deserialize("Name", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
pub struct CookieNameListSerializer;
impl CookieNameListSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &Vec<String>,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
for element in obj {
StringSerializer::serialize(writer, "Name", element)?;
}
writer.write(xml::writer::XmlEvent::end_element())?;
Ok(())
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CookieNames {
pub items: Option<Vec<String>>,
pub quantity: i64,
}
#[allow(dead_code)]
struct CookieNamesDeserializer;
impl CookieNamesDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CookieNames, XmlParseError> {
deserialize_elements::<_, CookieNames, _>(tag_name, stack, |name, stack, obj| {
match name {
"Items" => {
obj.items
.get_or_insert(vec![])
.extend(CookieNameListDeserializer::deserialize("Items", stack)?);
}
"Quantity" => {
obj.quantity = IntegerDeserializer::deserialize("Quantity", stack)?;
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
pub struct CookieNamesSerializer;
impl CookieNamesSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &CookieNames,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
if let Some(ref value) = obj.items {
&CookieNameListSerializer::serialize(&mut writer, "Items", value)?;
}
write_characters_element(writer, "Quantity", &obj.quantity.to_string())?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CookiePreference {
pub forward: String,
pub whitelisted_names: Option<CookieNames>,
}
#[allow(dead_code)]
struct CookiePreferenceDeserializer;
impl CookiePreferenceDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CookiePreference, XmlParseError> {
deserialize_elements::<_, CookiePreference, _>(tag_name, stack, |name, stack, obj| {
match name {
"Forward" => {
obj.forward = ItemSelectionDeserializer::deserialize("Forward", stack)?;
}
"WhitelistedNames" => {
obj.whitelisted_names = Some(CookieNamesDeserializer::deserialize(
"WhitelistedNames",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
pub struct CookiePreferenceSerializer;
impl CookiePreferenceSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &CookiePreference,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
write_characters_element(writer, "Forward", &obj.forward.to_string())?;
if let Some(ref value) = obj.whitelisted_names {
&CookieNamesSerializer::serialize(&mut writer, "WhitelistedNames", value)?;
}
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateCloudFrontOriginAccessIdentityRequest {
pub cloud_front_origin_access_identity_config: CloudFrontOriginAccessIdentityConfig,
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct CreateCloudFrontOriginAccessIdentityResult {
pub cloud_front_origin_access_identity: Option<CloudFrontOriginAccessIdentity>,
pub e_tag: Option<String>,
pub location: Option<String>,
}
#[allow(dead_code)]
struct CreateCloudFrontOriginAccessIdentityResultDeserializer;
impl CreateCloudFrontOriginAccessIdentityResultDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CreateCloudFrontOriginAccessIdentityResult, XmlParseError> {
Ok(CreateCloudFrontOriginAccessIdentityResult {
cloud_front_origin_access_identity: Some(
CloudFrontOriginAccessIdentityDeserializer::deserialize(
"CloudFrontOriginAccessIdentity",
stack,
)?,
),
..CreateCloudFrontOriginAccessIdentityResult::default()
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateDistributionRequest {
pub distribution_config: DistributionConfig,
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct CreateDistributionResult {
pub distribution: Option<Distribution>,
pub e_tag: Option<String>,
pub location: Option<String>,
}
#[allow(dead_code)]
struct CreateDistributionResultDeserializer;
impl CreateDistributionResultDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CreateDistributionResult, XmlParseError> {
Ok(CreateDistributionResult {
distribution: Some(DistributionDeserializer::deserialize(
"Distribution",
stack,
)?),
..CreateDistributionResult::default()
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateDistributionWithTagsRequest {
pub distribution_config_with_tags: DistributionConfigWithTags,
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct CreateDistributionWithTagsResult {
pub distribution: Option<Distribution>,
pub e_tag: Option<String>,
pub location: Option<String>,
}
#[allow(dead_code)]
struct CreateDistributionWithTagsResultDeserializer;
impl CreateDistributionWithTagsResultDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CreateDistributionWithTagsResult, XmlParseError> {
Ok(CreateDistributionWithTagsResult {
distribution: Some(DistributionDeserializer::deserialize(
"Distribution",
stack,
)?),
..CreateDistributionWithTagsResult::default()
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateFieldLevelEncryptionConfigRequest {
pub field_level_encryption_config: FieldLevelEncryptionConfig,
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct CreateFieldLevelEncryptionConfigResult {
pub e_tag: Option<String>,
pub field_level_encryption: Option<FieldLevelEncryption>,
pub location: Option<String>,
}
#[allow(dead_code)]
struct CreateFieldLevelEncryptionConfigResultDeserializer;
impl CreateFieldLevelEncryptionConfigResultDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CreateFieldLevelEncryptionConfigResult, XmlParseError> {
Ok(CreateFieldLevelEncryptionConfigResult {
field_level_encryption: Some(FieldLevelEncryptionDeserializer::deserialize(
"FieldLevelEncryption",
stack,
)?),
..CreateFieldLevelEncryptionConfigResult::default()
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateFieldLevelEncryptionProfileRequest {
pub field_level_encryption_profile_config: FieldLevelEncryptionProfileConfig,
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct CreateFieldLevelEncryptionProfileResult {
pub e_tag: Option<String>,
pub field_level_encryption_profile: Option<FieldLevelEncryptionProfile>,
pub location: Option<String>,
}
#[allow(dead_code)]
struct CreateFieldLevelEncryptionProfileResultDeserializer;
impl CreateFieldLevelEncryptionProfileResultDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CreateFieldLevelEncryptionProfileResult, XmlParseError> {
Ok(CreateFieldLevelEncryptionProfileResult {
field_level_encryption_profile: Some(
FieldLevelEncryptionProfileDeserializer::deserialize(
"FieldLevelEncryptionProfile",
stack,
)?,
),
..CreateFieldLevelEncryptionProfileResult::default()
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateInvalidationRequest {
pub distribution_id: String,
pub invalidation_batch: InvalidationBatch,
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct CreateInvalidationResult {
pub invalidation: Option<Invalidation>,
pub location: Option<String>,
}
#[allow(dead_code)]
struct CreateInvalidationResultDeserializer;
impl CreateInvalidationResultDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CreateInvalidationResult, XmlParseError> {
Ok(CreateInvalidationResult {
invalidation: Some(InvalidationDeserializer::deserialize(
"Invalidation",
stack,
)?),
..CreateInvalidationResult::default()
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreatePublicKeyRequest {
pub public_key_config: PublicKeyConfig,
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct CreatePublicKeyResult {
pub e_tag: Option<String>,
pub location: Option<String>,
pub public_key: Option<PublicKey>,
}
#[allow(dead_code)]
struct CreatePublicKeyResultDeserializer;
impl CreatePublicKeyResultDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CreatePublicKeyResult, XmlParseError> {
Ok(CreatePublicKeyResult {
public_key: Some(PublicKeyDeserializer::deserialize("PublicKey", stack)?),
..CreatePublicKeyResult::default()
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateStreamingDistributionRequest {
pub streaming_distribution_config: StreamingDistributionConfig,
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct CreateStreamingDistributionResult {
pub e_tag: Option<String>,
pub location: Option<String>,
pub streaming_distribution: Option<StreamingDistribution>,
}
#[allow(dead_code)]
struct CreateStreamingDistributionResultDeserializer;
impl CreateStreamingDistributionResultDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CreateStreamingDistributionResult, XmlParseError> {
Ok(CreateStreamingDistributionResult {
streaming_distribution: Some(StreamingDistributionDeserializer::deserialize(
"StreamingDistribution",
stack,
)?),
..CreateStreamingDistributionResult::default()
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateStreamingDistributionWithTagsRequest {
pub streaming_distribution_config_with_tags: StreamingDistributionConfigWithTags,
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct CreateStreamingDistributionWithTagsResult {
pub e_tag: Option<String>,
pub location: Option<String>,
pub streaming_distribution: Option<StreamingDistribution>,
}
#[allow(dead_code)]
struct CreateStreamingDistributionWithTagsResultDeserializer;
impl CreateStreamingDistributionWithTagsResultDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CreateStreamingDistributionWithTagsResult, XmlParseError> {
Ok(CreateStreamingDistributionWithTagsResult {
streaming_distribution: Some(StreamingDistributionDeserializer::deserialize(
"StreamingDistribution",
stack,
)?),
..CreateStreamingDistributionWithTagsResult::default()
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CustomErrorResponse {
pub error_caching_min_ttl: Option<i64>,
pub error_code: i64,
pub response_code: Option<String>,
pub response_page_path: Option<String>,
}
#[allow(dead_code)]
struct CustomErrorResponseDeserializer;
impl CustomErrorResponseDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CustomErrorResponse, XmlParseError> {
deserialize_elements::<_, CustomErrorResponse, _>(tag_name, stack, |name, stack, obj| {
match name {
"ErrorCachingMinTTL" => {
obj.error_caching_min_ttl =
Some(LongDeserializer::deserialize("ErrorCachingMinTTL", stack)?);
}
"ErrorCode" => {
obj.error_code = IntegerDeserializer::deserialize("ErrorCode", stack)?;
}
"ResponseCode" => {
obj.response_code =
Some(StringDeserializer::deserialize("ResponseCode", stack)?);
}
"ResponsePagePath" => {
obj.response_page_path =
Some(StringDeserializer::deserialize("ResponsePagePath", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
pub struct CustomErrorResponseSerializer;
impl CustomErrorResponseSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &CustomErrorResponse,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
if let Some(ref value) = obj.error_caching_min_ttl {
write_characters_element(writer, "ErrorCachingMinTTL", &value.to_string())?;
}
write_characters_element(writer, "ErrorCode", &obj.error_code.to_string())?;
if let Some(ref value) = obj.response_code {
write_characters_element(writer, "ResponseCode", &value.to_string())?;
}
if let Some(ref value) = obj.response_page_path {
write_characters_element(writer, "ResponsePagePath", &value.to_string())?;
}
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[allow(dead_code)]
struct CustomErrorResponseListDeserializer;
impl CustomErrorResponseListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<CustomErrorResponse>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "CustomErrorResponse" {
obj.push(CustomErrorResponseDeserializer::deserialize(
"CustomErrorResponse",
stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
pub struct CustomErrorResponseListSerializer;
impl CustomErrorResponseListSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &Vec<CustomErrorResponse>,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
for element in obj {
CustomErrorResponseSerializer::serialize(writer, "CustomErrorResponse", element)?;
}
writer.write(xml::writer::XmlEvent::end_element())?;
Ok(())
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CustomErrorResponses {
pub items: Option<Vec<CustomErrorResponse>>,
pub quantity: i64,
}
#[allow(dead_code)]
struct CustomErrorResponsesDeserializer;
impl CustomErrorResponsesDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CustomErrorResponses, XmlParseError> {
deserialize_elements::<_, CustomErrorResponses, _>(tag_name, stack, |name, stack, obj| {
match name {
"Items" => {
obj.items.get_or_insert(vec![]).extend(
CustomErrorResponseListDeserializer::deserialize("Items", stack)?,
);
}
"Quantity" => {
obj.quantity = IntegerDeserializer::deserialize("Quantity", stack)?;
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
pub struct CustomErrorResponsesSerializer;
impl CustomErrorResponsesSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &CustomErrorResponses,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
if let Some(ref value) = obj.items {
&CustomErrorResponseListSerializer::serialize(&mut writer, "Items", value)?;
}
write_characters_element(writer, "Quantity", &obj.quantity.to_string())?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CustomHeaders {
pub items: Option<Vec<OriginCustomHeader>>,
pub quantity: i64,
}
#[allow(dead_code)]
struct CustomHeadersDeserializer;
impl CustomHeadersDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CustomHeaders, XmlParseError> {
deserialize_elements::<_, CustomHeaders, _>(tag_name, stack, |name, stack, obj| {
match name {
"Items" => {
obj.items.get_or_insert(vec![]).extend(
OriginCustomHeadersListDeserializer::deserialize("Items", stack)?,
);
}
"Quantity" => {
obj.quantity = IntegerDeserializer::deserialize("Quantity", stack)?;
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
pub struct CustomHeadersSerializer;
impl CustomHeadersSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &CustomHeaders,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
if let Some(ref value) = obj.items {
&OriginCustomHeadersListSerializer::serialize(&mut writer, "Items", value)?;
}
write_characters_element(writer, "Quantity", &obj.quantity.to_string())?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CustomOriginConfig {
pub http_port: i64,
pub https_port: i64,
pub origin_keepalive_timeout: Option<i64>,
pub origin_protocol_policy: String,
pub origin_read_timeout: Option<i64>,
pub origin_ssl_protocols: Option<OriginSslProtocols>,
}
#[allow(dead_code)]
struct CustomOriginConfigDeserializer;
impl CustomOriginConfigDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CustomOriginConfig, XmlParseError> {
deserialize_elements::<_, CustomOriginConfig, _>(tag_name, stack, |name, stack, obj| {
match name {
"HTTPPort" => {
obj.http_port = IntegerDeserializer::deserialize("HTTPPort", stack)?;
}
"HTTPSPort" => {
obj.https_port = IntegerDeserializer::deserialize("HTTPSPort", stack)?;
}
"OriginKeepaliveTimeout" => {
obj.origin_keepalive_timeout = Some(IntegerDeserializer::deserialize(
"OriginKeepaliveTimeout",
stack,
)?);
}
"OriginProtocolPolicy" => {
obj.origin_protocol_policy = OriginProtocolPolicyDeserializer::deserialize(
"OriginProtocolPolicy",
stack,
)?;
}
"OriginReadTimeout" => {
obj.origin_read_timeout = Some(IntegerDeserializer::deserialize(
"OriginReadTimeout",
stack,
)?);
}
"OriginSslProtocols" => {
obj.origin_ssl_protocols = Some(OriginSslProtocolsDeserializer::deserialize(
"OriginSslProtocols",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
pub struct CustomOriginConfigSerializer;
impl CustomOriginConfigSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &CustomOriginConfig,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
write_characters_element(writer, "HTTPPort", &obj.http_port.to_string())?;
write_characters_element(writer, "HTTPSPort", &obj.https_port.to_string())?;
if let Some(ref value) = obj.origin_keepalive_timeout {
write_characters_element(writer, "OriginKeepaliveTimeout", &value.to_string())?;
}
write_characters_element(
writer,
"OriginProtocolPolicy",
&obj.origin_protocol_policy.to_string(),
)?;
if let Some(ref value) = obj.origin_read_timeout {
write_characters_element(writer, "OriginReadTimeout", &value.to_string())?;
}
if let Some(ref value) = obj.origin_ssl_protocols {
&OriginSslProtocolsSerializer::serialize(&mut writer, "OriginSslProtocols", value)?;
}
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DefaultCacheBehavior {
pub allowed_methods: Option<AllowedMethods>,
pub compress: Option<bool>,
pub default_ttl: Option<i64>,
pub field_level_encryption_id: Option<String>,
pub forwarded_values: ForwardedValues,
pub lambda_function_associations: Option<LambdaFunctionAssociations>,
pub max_ttl: Option<i64>,
pub min_ttl: i64,
pub smooth_streaming: Option<bool>,
pub target_origin_id: String,
pub trusted_signers: TrustedSigners,
pub viewer_protocol_policy: String,
}
#[allow(dead_code)]
struct DefaultCacheBehaviorDeserializer;
impl DefaultCacheBehaviorDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DefaultCacheBehavior, XmlParseError> {
deserialize_elements::<_, DefaultCacheBehavior, _>(tag_name, stack, |name, stack, obj| {
match name {
"AllowedMethods" => {
obj.allowed_methods = Some(AllowedMethodsDeserializer::deserialize(
"AllowedMethods",
stack,
)?);
}
"Compress" => {
obj.compress = Some(BooleanDeserializer::deserialize("Compress", stack)?);
}
"DefaultTTL" => {
obj.default_ttl = Some(LongDeserializer::deserialize("DefaultTTL", stack)?);
}
"FieldLevelEncryptionId" => {
obj.field_level_encryption_id = Some(StringDeserializer::deserialize(
"FieldLevelEncryptionId",
stack,
)?);
}
"ForwardedValues" => {
obj.forwarded_values =
ForwardedValuesDeserializer::deserialize("ForwardedValues", stack)?;
}
"LambdaFunctionAssociations" => {
obj.lambda_function_associations =
Some(LambdaFunctionAssociationsDeserializer::deserialize(
"LambdaFunctionAssociations",
stack,
)?);
}
"MaxTTL" => {
obj.max_ttl = Some(LongDeserializer::deserialize("MaxTTL", stack)?);
}
"MinTTL" => {
obj.min_ttl = LongDeserializer::deserialize("MinTTL", stack)?;
}
"SmoothStreaming" => {
obj.smooth_streaming =
Some(BooleanDeserializer::deserialize("SmoothStreaming", stack)?);
}
"TargetOriginId" => {
obj.target_origin_id =
StringDeserializer::deserialize("TargetOriginId", stack)?;
}
"TrustedSigners" => {
obj.trusted_signers =
TrustedSignersDeserializer::deserialize("TrustedSigners", stack)?;
}
"ViewerProtocolPolicy" => {
obj.viewer_protocol_policy = ViewerProtocolPolicyDeserializer::deserialize(
"ViewerProtocolPolicy",
stack,
)?;
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
pub struct DefaultCacheBehaviorSerializer;
impl DefaultCacheBehaviorSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &DefaultCacheBehavior,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
if let Some(ref value) = obj.allowed_methods {
&AllowedMethodsSerializer::serialize(&mut writer, "AllowedMethods", value)?;
}
if let Some(ref value) = obj.compress {
write_characters_element(writer, "Compress", &value.to_string())?;
}
if let Some(ref value) = obj.default_ttl {
write_characters_element(writer, "DefaultTTL", &value.to_string())?;
}
if let Some(ref value) = obj.field_level_encryption_id {
write_characters_element(writer, "FieldLevelEncryptionId", &value.to_string())?;
}
ForwardedValuesSerializer::serialize(
&mut writer,
"ForwardedValues",
&obj.forwarded_values,
)?;
if let Some(ref value) = obj.lambda_function_associations {
&LambdaFunctionAssociationsSerializer::serialize(
&mut writer,
"LambdaFunctionAssociations",
value,
)?;
}
if let Some(ref value) = obj.max_ttl {
write_characters_element(writer, "MaxTTL", &value.to_string())?;
}
write_characters_element(writer, "MinTTL", &obj.min_ttl.to_string())?;
if let Some(ref value) = obj.smooth_streaming {
write_characters_element(writer, "SmoothStreaming", &value.to_string())?;
}
write_characters_element(writer, "TargetOriginId", &obj.target_origin_id.to_string())?;
TrustedSignersSerializer::serialize(&mut writer, "TrustedSigners", &obj.trusted_signers)?;
write_characters_element(
writer,
"ViewerProtocolPolicy",
&obj.viewer_protocol_policy.to_string(),
)?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteCloudFrontOriginAccessIdentityRequest {
pub id: String,
pub if_match: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteDistributionRequest {
pub id: String,
pub if_match: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteFieldLevelEncryptionConfigRequest {
pub id: String,
pub if_match: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteFieldLevelEncryptionProfileRequest {
pub id: String,
pub if_match: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeletePublicKeyRequest {
pub id: String,
pub if_match: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteStreamingDistributionRequest {
pub id: String,
pub if_match: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct Distribution {
pub arn: String,
pub active_trusted_signers: ActiveTrustedSigners,
pub alias_icp_recordals: Option<Vec<AliasICPRecordal>>,
pub distribution_config: DistributionConfig,
pub domain_name: String,
pub id: String,
pub in_progress_invalidation_batches: i64,
pub last_modified_time: String,
pub status: String,
}
#[allow(dead_code)]
struct DistributionDeserializer;
impl DistributionDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Distribution, XmlParseError> {
deserialize_elements::<_, Distribution, _>(tag_name, stack, |name, stack, obj| {
match name {
"ARN" => {
obj.arn = StringDeserializer::deserialize("ARN", stack)?;
}
"ActiveTrustedSigners" => {
obj.active_trusted_signers = ActiveTrustedSignersDeserializer::deserialize(
"ActiveTrustedSigners",
stack,
)?;
}
"AliasICPRecordals" => {
obj.alias_icp_recordals.get_or_insert(vec![]).extend(
AliasICPRecordalsDeserializer::deserialize("AliasICPRecordals", stack)?,
);
}
"DistributionConfig" => {
obj.distribution_config =
DistributionConfigDeserializer::deserialize("DistributionConfig", stack)?;
}
"DomainName" => {
obj.domain_name = StringDeserializer::deserialize("DomainName", stack)?;
}
"Id" => {
obj.id = StringDeserializer::deserialize("Id", stack)?;
}
"InProgressInvalidationBatches" => {
obj.in_progress_invalidation_batches =
IntegerDeserializer::deserialize("InProgressInvalidationBatches", stack)?;
}
"LastModifiedTime" => {
obj.last_modified_time =
TimestampDeserializer::deserialize("LastModifiedTime", stack)?;
}
"Status" => {
obj.status = StringDeserializer::deserialize("Status", stack)?;
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DistributionConfig {
pub aliases: Option<Aliases>,
pub cache_behaviors: Option<CacheBehaviors>,
pub caller_reference: String,
pub comment: String,
pub custom_error_responses: Option<CustomErrorResponses>,
pub default_cache_behavior: DefaultCacheBehavior,
pub default_root_object: Option<String>,
pub enabled: bool,
pub http_version: Option<String>,
pub is_ipv6_enabled: Option<bool>,
pub logging: Option<LoggingConfig>,
pub origin_groups: Option<OriginGroups>,
pub origins: Origins,
pub price_class: Option<String>,
pub restrictions: Option<Restrictions>,
pub viewer_certificate: Option<ViewerCertificate>,
pub web_acl_id: Option<String>,
}
#[allow(dead_code)]
struct DistributionConfigDeserializer;
impl DistributionConfigDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DistributionConfig, XmlParseError> {
deserialize_elements::<_, DistributionConfig, _>(tag_name, stack, |name, stack, obj| {
match name {
"Aliases" => {
obj.aliases = Some(AliasesDeserializer::deserialize("Aliases", stack)?);
}
"CacheBehaviors" => {
obj.cache_behaviors = Some(CacheBehaviorsDeserializer::deserialize(
"CacheBehaviors",
stack,
)?);
}
"CallerReference" => {
obj.caller_reference =
StringDeserializer::deserialize("CallerReference", stack)?;
}
"Comment" => {
obj.comment = CommentTypeDeserializer::deserialize("Comment", stack)?;
}
"CustomErrorResponses" => {
obj.custom_error_responses =
Some(CustomErrorResponsesDeserializer::deserialize(
"CustomErrorResponses",
stack,
)?);
}
"DefaultCacheBehavior" => {
obj.default_cache_behavior = DefaultCacheBehaviorDeserializer::deserialize(
"DefaultCacheBehavior",
stack,
)?;
}
"DefaultRootObject" => {
obj.default_root_object =
Some(StringDeserializer::deserialize("DefaultRootObject", stack)?);
}
"Enabled" => {
obj.enabled = BooleanDeserializer::deserialize("Enabled", stack)?;
}
"HttpVersion" => {
obj.http_version =
Some(HttpVersionDeserializer::deserialize("HttpVersion", stack)?);
}
"IsIPV6Enabled" => {
obj.is_ipv6_enabled =
Some(BooleanDeserializer::deserialize("IsIPV6Enabled", stack)?);
}
"Logging" => {
obj.logging = Some(LoggingConfigDeserializer::deserialize("Logging", stack)?);
}
"OriginGroups" => {
obj.origin_groups = Some(OriginGroupsDeserializer::deserialize(
"OriginGroups",
stack,
)?);
}
"Origins" => {
obj.origins = OriginsDeserializer::deserialize("Origins", stack)?;
}
"PriceClass" => {
obj.price_class =
Some(PriceClassDeserializer::deserialize("PriceClass", stack)?);
}
"Restrictions" => {
obj.restrictions = Some(RestrictionsDeserializer::deserialize(
"Restrictions",
stack,
)?);
}
"ViewerCertificate" => {
obj.viewer_certificate = Some(ViewerCertificateDeserializer::deserialize(
"ViewerCertificate",
stack,
)?);
}
"WebACLId" => {
obj.web_acl_id = Some(StringDeserializer::deserialize("WebACLId", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
pub struct DistributionConfigSerializer;
impl DistributionConfigSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &DistributionConfig,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
if let Some(ref value) = obj.aliases {
&AliasesSerializer::serialize(&mut writer, "Aliases", value)?;
}
if let Some(ref value) = obj.cache_behaviors {
&CacheBehaviorsSerializer::serialize(&mut writer, "CacheBehaviors", value)?;
}
write_characters_element(writer, "CallerReference", &obj.caller_reference.to_string())?;
write_characters_element(writer, "Comment", &obj.comment.to_string())?;
if let Some(ref value) = obj.custom_error_responses {
&CustomErrorResponsesSerializer::serialize(&mut writer, "CustomErrorResponses", value)?;
}
DefaultCacheBehaviorSerializer::serialize(
&mut writer,
"DefaultCacheBehavior",
&obj.default_cache_behavior,
)?;
if let Some(ref value) = obj.default_root_object {
write_characters_element(writer, "DefaultRootObject", &value.to_string())?;
}
write_characters_element(writer, "Enabled", &obj.enabled.to_string())?;
if let Some(ref value) = obj.http_version {
write_characters_element(writer, "HttpVersion", &value.to_string())?;
}
if let Some(ref value) = obj.is_ipv6_enabled {
write_characters_element(writer, "IsIPV6Enabled", &value.to_string())?;
}
if let Some(ref value) = obj.logging {
&LoggingConfigSerializer::serialize(&mut writer, "Logging", value)?;
}
if let Some(ref value) = obj.origin_groups {
&OriginGroupsSerializer::serialize(&mut writer, "OriginGroups", value)?;
}
OriginsSerializer::serialize(&mut writer, "Origins", &obj.origins)?;
if let Some(ref value) = obj.price_class {
write_characters_element(writer, "PriceClass", &value.to_string())?;
}
if let Some(ref value) = obj.restrictions {
&RestrictionsSerializer::serialize(&mut writer, "Restrictions", value)?;
}
if let Some(ref value) = obj.viewer_certificate {
&ViewerCertificateSerializer::serialize(&mut writer, "ViewerCertificate", value)?;
}
if let Some(ref value) = obj.web_acl_id {
write_characters_element(writer, "WebACLId", &value.to_string())?;
}
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DistributionConfigWithTags {
pub distribution_config: DistributionConfig,
pub tags: Tags,
}
pub struct DistributionConfigWithTagsSerializer;
impl DistributionConfigWithTagsSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &DistributionConfigWithTags,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
DistributionConfigSerializer::serialize(
&mut writer,
"DistributionConfig",
&obj.distribution_config,
)?;
TagsSerializer::serialize(&mut writer, "Tags", &obj.tags)?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct DistributionList {
pub is_truncated: bool,
pub items: Option<Vec<DistributionSummary>>,
pub marker: String,
pub max_items: i64,
pub next_marker: Option<String>,
pub quantity: i64,
}
#[allow(dead_code)]
struct DistributionListDeserializer;
impl DistributionListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DistributionList, XmlParseError> {
deserialize_elements::<_, DistributionList, _>(tag_name, stack, |name, stack, obj| {
match name {
"IsTruncated" => {
obj.is_truncated = BooleanDeserializer::deserialize("IsTruncated", stack)?;
}
"Items" => {
obj.items.get_or_insert(vec![]).extend(
DistributionSummaryListDeserializer::deserialize("Items", stack)?,
);
}
"Marker" => {
obj.marker = StringDeserializer::deserialize("Marker", stack)?;
}
"MaxItems" => {
obj.max_items = IntegerDeserializer::deserialize("MaxItems", stack)?;
}
"NextMarker" => {
obj.next_marker = Some(StringDeserializer::deserialize("NextMarker", stack)?);
}
"Quantity" => {
obj.quantity = IntegerDeserializer::deserialize("Quantity", stack)?;
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct DistributionSummary {
pub arn: String,
pub alias_icp_recordals: Option<Vec<AliasICPRecordal>>,
pub aliases: Aliases,
pub cache_behaviors: CacheBehaviors,
pub comment: String,
pub custom_error_responses: CustomErrorResponses,
pub default_cache_behavior: DefaultCacheBehavior,
pub domain_name: String,
pub enabled: bool,
pub http_version: String,
pub id: String,
pub is_ipv6_enabled: bool,
pub last_modified_time: String,
pub origin_groups: Option<OriginGroups>,
pub origins: Origins,
pub price_class: String,
pub restrictions: Restrictions,
pub status: String,
pub viewer_certificate: ViewerCertificate,
pub web_acl_id: String,
}
#[allow(dead_code)]
struct DistributionSummaryDeserializer;
impl DistributionSummaryDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DistributionSummary, XmlParseError> {
deserialize_elements::<_, DistributionSummary, _>(tag_name, stack, |name, stack, obj| {
match name {
"ARN" => {
obj.arn = StringDeserializer::deserialize("ARN", stack)?;
}
"AliasICPRecordals" => {
obj.alias_icp_recordals.get_or_insert(vec![]).extend(
AliasICPRecordalsDeserializer::deserialize("AliasICPRecordals", stack)?,
);
}
"Aliases" => {
obj.aliases = AliasesDeserializer::deserialize("Aliases", stack)?;
}
"CacheBehaviors" => {
obj.cache_behaviors =
CacheBehaviorsDeserializer::deserialize("CacheBehaviors", stack)?;
}
"Comment" => {
obj.comment = StringDeserializer::deserialize("Comment", stack)?;
}
"CustomErrorResponses" => {
obj.custom_error_responses = CustomErrorResponsesDeserializer::deserialize(
"CustomErrorResponses",
stack,
)?;
}
"DefaultCacheBehavior" => {
obj.default_cache_behavior = DefaultCacheBehaviorDeserializer::deserialize(
"DefaultCacheBehavior",
stack,
)?;
}
"DomainName" => {
obj.domain_name = StringDeserializer::deserialize("DomainName", stack)?;
}
"Enabled" => {
obj.enabled = BooleanDeserializer::deserialize("Enabled", stack)?;
}
"HttpVersion" => {
obj.http_version = HttpVersionDeserializer::deserialize("HttpVersion", stack)?;
}
"Id" => {
obj.id = StringDeserializer::deserialize("Id", stack)?;
}
"IsIPV6Enabled" => {
obj.is_ipv6_enabled = BooleanDeserializer::deserialize("IsIPV6Enabled", stack)?;
}
"LastModifiedTime" => {
obj.last_modified_time =
TimestampDeserializer::deserialize("LastModifiedTime", stack)?;
}
"OriginGroups" => {
obj.origin_groups = Some(OriginGroupsDeserializer::deserialize(
"OriginGroups",
stack,
)?);
}
"Origins" => {
obj.origins = OriginsDeserializer::deserialize("Origins", stack)?;
}
"PriceClass" => {
obj.price_class = PriceClassDeserializer::deserialize("PriceClass", stack)?;
}
"Restrictions" => {
obj.restrictions =
RestrictionsDeserializer::deserialize("Restrictions", stack)?;
}
"Status" => {
obj.status = StringDeserializer::deserialize("Status", stack)?;
}
"ViewerCertificate" => {
obj.viewer_certificate =
ViewerCertificateDeserializer::deserialize("ViewerCertificate", stack)?;
}
"WebACLId" => {
obj.web_acl_id = StringDeserializer::deserialize("WebACLId", stack)?;
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[allow(dead_code)]
struct DistributionSummaryListDeserializer;
impl DistributionSummaryListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<DistributionSummary>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "DistributionSummary" {
obj.push(DistributionSummaryDeserializer::deserialize(
"DistributionSummary",
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 EncryptionEntities {
pub items: Option<Vec<EncryptionEntity>>,
pub quantity: i64,
}
#[allow(dead_code)]
struct EncryptionEntitiesDeserializer;
impl EncryptionEntitiesDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<EncryptionEntities, XmlParseError> {
deserialize_elements::<_, EncryptionEntities, _>(tag_name, stack, |name, stack, obj| {
match name {
"Items" => {
obj.items.get_or_insert(vec![]).extend(
EncryptionEntityListDeserializer::deserialize("Items", stack)?,
);
}
"Quantity" => {
obj.quantity = IntegerDeserializer::deserialize("Quantity", stack)?;
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
pub struct EncryptionEntitiesSerializer;
impl EncryptionEntitiesSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &EncryptionEntities,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
if let Some(ref value) = obj.items {
&EncryptionEntityListSerializer::serialize(&mut writer, "Items", value)?;
}
write_characters_element(writer, "Quantity", &obj.quantity.to_string())?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct EncryptionEntity {
pub field_patterns: FieldPatterns,
pub provider_id: String,
pub public_key_id: String,
}
#[allow(dead_code)]
struct EncryptionEntityDeserializer;
impl EncryptionEntityDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<EncryptionEntity, XmlParseError> {
deserialize_elements::<_, EncryptionEntity, _>(tag_name, stack, |name, stack, obj| {
match name {
"FieldPatterns" => {
obj.field_patterns =
FieldPatternsDeserializer::deserialize("FieldPatterns", stack)?;
}
"ProviderId" => {
obj.provider_id = StringDeserializer::deserialize("ProviderId", stack)?;
}
"PublicKeyId" => {
obj.public_key_id = StringDeserializer::deserialize("PublicKeyId", stack)?;
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
pub struct EncryptionEntitySerializer;
impl EncryptionEntitySerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &EncryptionEntity,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
FieldPatternsSerializer::serialize(&mut writer, "FieldPatterns", &obj.field_patterns)?;
write_characters_element(writer, "ProviderId", &obj.provider_id.to_string())?;
write_characters_element(writer, "PublicKeyId", &obj.public_key_id.to_string())?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[allow(dead_code)]
struct EncryptionEntityListDeserializer;
impl EncryptionEntityListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<EncryptionEntity>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "EncryptionEntity" {
obj.push(EncryptionEntityDeserializer::deserialize(
"EncryptionEntity",
stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
pub struct EncryptionEntityListSerializer;
impl EncryptionEntityListSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &Vec<EncryptionEntity>,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
for element in obj {
EncryptionEntitySerializer::serialize(writer, "EncryptionEntity", element)?;
}
writer.write(xml::writer::XmlEvent::end_element())?;
Ok(())
}
}
#[allow(dead_code)]
struct EventTypeDeserializer;
impl EventTypeDeserializer {
#[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)
}
}
pub struct EventTypeSerializer;
impl EventTypeSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &String,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
write_characters_element(writer, name, obj)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct FieldLevelEncryption {
pub field_level_encryption_config: FieldLevelEncryptionConfig,
pub id: String,
pub last_modified_time: String,
}
#[allow(dead_code)]
struct FieldLevelEncryptionDeserializer;
impl FieldLevelEncryptionDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<FieldLevelEncryption, XmlParseError> {
deserialize_elements::<_, FieldLevelEncryption, _>(tag_name, stack, |name, stack, obj| {
match name {
"FieldLevelEncryptionConfig" => {
obj.field_level_encryption_config =
FieldLevelEncryptionConfigDeserializer::deserialize(
"FieldLevelEncryptionConfig",
stack,
)?;
}
"Id" => {
obj.id = StringDeserializer::deserialize("Id", stack)?;
}
"LastModifiedTime" => {
obj.last_modified_time =
TimestampDeserializer::deserialize("LastModifiedTime", stack)?;
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct FieldLevelEncryptionConfig {
pub caller_reference: String,
pub comment: Option<String>,
pub content_type_profile_config: Option<ContentTypeProfileConfig>,
pub query_arg_profile_config: Option<QueryArgProfileConfig>,
}
#[allow(dead_code)]
struct FieldLevelEncryptionConfigDeserializer;
impl FieldLevelEncryptionConfigDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<FieldLevelEncryptionConfig, XmlParseError> {
deserialize_elements::<_, FieldLevelEncryptionConfig, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"CallerReference" => {
obj.caller_reference =
StringDeserializer::deserialize("CallerReference", stack)?;
}
"Comment" => {
obj.comment = Some(StringDeserializer::deserialize("Comment", stack)?);
}
"ContentTypeProfileConfig" => {
obj.content_type_profile_config =
Some(ContentTypeProfileConfigDeserializer::deserialize(
"ContentTypeProfileConfig",
stack,
)?);
}
"QueryArgProfileConfig" => {
obj.query_arg_profile_config =
Some(QueryArgProfileConfigDeserializer::deserialize(
"QueryArgProfileConfig",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
pub struct FieldLevelEncryptionConfigSerializer;
impl FieldLevelEncryptionConfigSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &FieldLevelEncryptionConfig,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
write_characters_element(writer, "CallerReference", &obj.caller_reference.to_string())?;
if let Some(ref value) = obj.comment {
write_characters_element(writer, "Comment", &value.to_string())?;
}
if let Some(ref value) = obj.content_type_profile_config {
&ContentTypeProfileConfigSerializer::serialize(
&mut writer,
"ContentTypeProfileConfig",
value,
)?;
}
if let Some(ref value) = obj.query_arg_profile_config {
&QueryArgProfileConfigSerializer::serialize(
&mut writer,
"QueryArgProfileConfig",
value,
)?;
}
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct FieldLevelEncryptionList {
pub items: Option<Vec<FieldLevelEncryptionSummary>>,
pub max_items: i64,
pub next_marker: Option<String>,
pub quantity: i64,
}
#[allow(dead_code)]
struct FieldLevelEncryptionListDeserializer;
impl FieldLevelEncryptionListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<FieldLevelEncryptionList, XmlParseError> {
deserialize_elements::<_, FieldLevelEncryptionList, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"Items" => {
obj.items.get_or_insert(vec![]).extend(
FieldLevelEncryptionSummaryListDeserializer::deserialize(
"Items", stack,
)?,
);
}
"MaxItems" => {
obj.max_items = IntegerDeserializer::deserialize("MaxItems", stack)?;
}
"NextMarker" => {
obj.next_marker =
Some(StringDeserializer::deserialize("NextMarker", stack)?);
}
"Quantity" => {
obj.quantity = IntegerDeserializer::deserialize("Quantity", stack)?;
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct FieldLevelEncryptionProfile {
pub field_level_encryption_profile_config: FieldLevelEncryptionProfileConfig,
pub id: String,
pub last_modified_time: String,
}
#[allow(dead_code)]
struct FieldLevelEncryptionProfileDeserializer;
impl FieldLevelEncryptionProfileDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<FieldLevelEncryptionProfile, XmlParseError> {
deserialize_elements::<_, FieldLevelEncryptionProfile, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"FieldLevelEncryptionProfileConfig" => {
obj.field_level_encryption_profile_config =
FieldLevelEncryptionProfileConfigDeserializer::deserialize(
"FieldLevelEncryptionProfileConfig",
stack,
)?;
}
"Id" => {
obj.id = StringDeserializer::deserialize("Id", stack)?;
}
"LastModifiedTime" => {
obj.last_modified_time =
TimestampDeserializer::deserialize("LastModifiedTime", stack)?;
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct FieldLevelEncryptionProfileConfig {
pub caller_reference: String,
pub comment: Option<String>,
pub encryption_entities: EncryptionEntities,
pub name: String,
}
#[allow(dead_code)]
struct FieldLevelEncryptionProfileConfigDeserializer;
impl FieldLevelEncryptionProfileConfigDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<FieldLevelEncryptionProfileConfig, XmlParseError> {
deserialize_elements::<_, FieldLevelEncryptionProfileConfig, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"CallerReference" => {
obj.caller_reference =
StringDeserializer::deserialize("CallerReference", stack)?;
}
"Comment" => {
obj.comment = Some(StringDeserializer::deserialize("Comment", stack)?);
}
"EncryptionEntities" => {
obj.encryption_entities = EncryptionEntitiesDeserializer::deserialize(
"EncryptionEntities",
stack,
)?;
}
"Name" => {
obj.name = StringDeserializer::deserialize("Name", stack)?;
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
pub struct FieldLevelEncryptionProfileConfigSerializer;
impl FieldLevelEncryptionProfileConfigSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &FieldLevelEncryptionProfileConfig,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
write_characters_element(writer, "CallerReference", &obj.caller_reference.to_string())?;
if let Some(ref value) = obj.comment {
write_characters_element(writer, "Comment", &value.to_string())?;
}
EncryptionEntitiesSerializer::serialize(
&mut writer,
"EncryptionEntities",
&obj.encryption_entities,
)?;
write_characters_element(writer, "Name", &obj.name.to_string())?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct FieldLevelEncryptionProfileList {
pub items: Option<Vec<FieldLevelEncryptionProfileSummary>>,
pub max_items: i64,
pub next_marker: Option<String>,
pub quantity: i64,
}
#[allow(dead_code)]
struct FieldLevelEncryptionProfileListDeserializer;
impl FieldLevelEncryptionProfileListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<FieldLevelEncryptionProfileList, XmlParseError> {
deserialize_elements::<_, FieldLevelEncryptionProfileList, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"Items" => {
obj.items.get_or_insert(vec![]).extend(
FieldLevelEncryptionProfileSummaryListDeserializer::deserialize(
"Items", stack,
)?,
);
}
"MaxItems" => {
obj.max_items = IntegerDeserializer::deserialize("MaxItems", stack)?;
}
"NextMarker" => {
obj.next_marker =
Some(StringDeserializer::deserialize("NextMarker", stack)?);
}
"Quantity" => {
obj.quantity = IntegerDeserializer::deserialize("Quantity", stack)?;
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct FieldLevelEncryptionProfileSummary {
pub comment: Option<String>,
pub encryption_entities: EncryptionEntities,
pub id: String,
pub last_modified_time: String,
pub name: String,
}
#[allow(dead_code)]
struct FieldLevelEncryptionProfileSummaryDeserializer;
impl FieldLevelEncryptionProfileSummaryDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<FieldLevelEncryptionProfileSummary, XmlParseError> {
deserialize_elements::<_, FieldLevelEncryptionProfileSummary, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"Comment" => {
obj.comment = Some(StringDeserializer::deserialize("Comment", stack)?);
}
"EncryptionEntities" => {
obj.encryption_entities = EncryptionEntitiesDeserializer::deserialize(
"EncryptionEntities",
stack,
)?;
}
"Id" => {
obj.id = StringDeserializer::deserialize("Id", stack)?;
}
"LastModifiedTime" => {
obj.last_modified_time =
TimestampDeserializer::deserialize("LastModifiedTime", stack)?;
}
"Name" => {
obj.name = StringDeserializer::deserialize("Name", stack)?;
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[allow(dead_code)]
struct FieldLevelEncryptionProfileSummaryListDeserializer;
impl FieldLevelEncryptionProfileSummaryListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<FieldLevelEncryptionProfileSummary>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "FieldLevelEncryptionProfileSummary" {
obj.push(FieldLevelEncryptionProfileSummaryDeserializer::deserialize(
"FieldLevelEncryptionProfileSummary",
stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct FieldLevelEncryptionSummary {
pub comment: Option<String>,
pub content_type_profile_config: Option<ContentTypeProfileConfig>,
pub id: String,
pub last_modified_time: String,
pub query_arg_profile_config: Option<QueryArgProfileConfig>,
}
#[allow(dead_code)]
struct FieldLevelEncryptionSummaryDeserializer;
impl FieldLevelEncryptionSummaryDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<FieldLevelEncryptionSummary, XmlParseError> {
deserialize_elements::<_, FieldLevelEncryptionSummary, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"Comment" => {
obj.comment = Some(StringDeserializer::deserialize("Comment", stack)?);
}
"ContentTypeProfileConfig" => {
obj.content_type_profile_config =
Some(ContentTypeProfileConfigDeserializer::deserialize(
"ContentTypeProfileConfig",
stack,
)?);
}
"Id" => {
obj.id = StringDeserializer::deserialize("Id", stack)?;
}
"LastModifiedTime" => {
obj.last_modified_time =
TimestampDeserializer::deserialize("LastModifiedTime", stack)?;
}
"QueryArgProfileConfig" => {
obj.query_arg_profile_config =
Some(QueryArgProfileConfigDeserializer::deserialize(
"QueryArgProfileConfig",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[allow(dead_code)]
struct FieldLevelEncryptionSummaryListDeserializer;
impl FieldLevelEncryptionSummaryListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<FieldLevelEncryptionSummary>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "FieldLevelEncryptionSummary" {
obj.push(FieldLevelEncryptionSummaryDeserializer::deserialize(
"FieldLevelEncryptionSummary",
stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[allow(dead_code)]
struct FieldPatternListDeserializer;
impl FieldPatternListDeserializer {
#[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 == "FieldPattern" {
obj.push(StringDeserializer::deserialize("FieldPattern", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
pub struct FieldPatternListSerializer;
impl FieldPatternListSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &Vec<String>,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
for element in obj {
StringSerializer::serialize(writer, "FieldPattern", element)?;
}
writer.write(xml::writer::XmlEvent::end_element())?;
Ok(())
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct FieldPatterns {
pub items: Option<Vec<String>>,
pub quantity: i64,
}
#[allow(dead_code)]
struct FieldPatternsDeserializer;
impl FieldPatternsDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<FieldPatterns, XmlParseError> {
deserialize_elements::<_, FieldPatterns, _>(tag_name, stack, |name, stack, obj| {
match name {
"Items" => {
obj.items
.get_or_insert(vec![])
.extend(FieldPatternListDeserializer::deserialize("Items", stack)?);
}
"Quantity" => {
obj.quantity = IntegerDeserializer::deserialize("Quantity", stack)?;
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
pub struct FieldPatternsSerializer;
impl FieldPatternsSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &FieldPatterns,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
if let Some(ref value) = obj.items {
&FieldPatternListSerializer::serialize(&mut writer, "Items", value)?;
}
write_characters_element(writer, "Quantity", &obj.quantity.to_string())?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[allow(dead_code)]
struct FormatDeserializer;
impl FormatDeserializer {
#[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)
}
}
pub struct FormatSerializer;
impl FormatSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &String,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
write_characters_element(writer, name, obj)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ForwardedValues {
pub cookies: CookiePreference,
pub headers: Option<Headers>,
pub query_string: bool,
pub query_string_cache_keys: Option<QueryStringCacheKeys>,
}
#[allow(dead_code)]
struct ForwardedValuesDeserializer;
impl ForwardedValuesDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ForwardedValues, XmlParseError> {
deserialize_elements::<_, ForwardedValues, _>(tag_name, stack, |name, stack, obj| {
match name {
"Cookies" => {
obj.cookies = CookiePreferenceDeserializer::deserialize("Cookies", stack)?;
}
"Headers" => {
obj.headers = Some(HeadersDeserializer::deserialize("Headers", stack)?);
}
"QueryString" => {
obj.query_string = BooleanDeserializer::deserialize("QueryString", stack)?;
}
"QueryStringCacheKeys" => {
obj.query_string_cache_keys =
Some(QueryStringCacheKeysDeserializer::deserialize(
"QueryStringCacheKeys",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
pub struct ForwardedValuesSerializer;
impl ForwardedValuesSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &ForwardedValues,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
CookiePreferenceSerializer::serialize(&mut writer, "Cookies", &obj.cookies)?;
if let Some(ref value) = obj.headers {
&HeadersSerializer::serialize(&mut writer, "Headers", value)?;
}
write_characters_element(writer, "QueryString", &obj.query_string.to_string())?;
if let Some(ref value) = obj.query_string_cache_keys {
&QueryStringCacheKeysSerializer::serialize(&mut writer, "QueryStringCacheKeys", value)?;
}
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GeoRestriction {
pub items: Option<Vec<String>>,
pub quantity: i64,
pub restriction_type: String,
}
#[allow(dead_code)]
struct GeoRestrictionDeserializer;
impl GeoRestrictionDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<GeoRestriction, XmlParseError> {
deserialize_elements::<_, GeoRestriction, _>(tag_name, stack, |name, stack, obj| {
match name {
"Items" => {
obj.items
.get_or_insert(vec![])
.extend(LocationListDeserializer::deserialize("Items", stack)?);
}
"Quantity" => {
obj.quantity = IntegerDeserializer::deserialize("Quantity", stack)?;
}
"RestrictionType" => {
obj.restriction_type =
GeoRestrictionTypeDeserializer::deserialize("RestrictionType", stack)?;
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
pub struct GeoRestrictionSerializer;
impl GeoRestrictionSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &GeoRestriction,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
if let Some(ref value) = obj.items {
&LocationListSerializer::serialize(&mut writer, "Items", value)?;
}
write_characters_element(writer, "Quantity", &obj.quantity.to_string())?;
write_characters_element(writer, "RestrictionType", &obj.restriction_type.to_string())?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[allow(dead_code)]
struct GeoRestrictionTypeDeserializer;
impl GeoRestrictionTypeDeserializer {
#[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)
}
}
pub struct GeoRestrictionTypeSerializer;
impl GeoRestrictionTypeSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &String,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
write_characters_element(writer, name, obj)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetCloudFrontOriginAccessIdentityConfigRequest {
pub id: String,
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct GetCloudFrontOriginAccessIdentityConfigResult {
pub cloud_front_origin_access_identity_config: Option<CloudFrontOriginAccessIdentityConfig>,
pub e_tag: Option<String>,
}
#[allow(dead_code)]
struct GetCloudFrontOriginAccessIdentityConfigResultDeserializer;
impl GetCloudFrontOriginAccessIdentityConfigResultDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<GetCloudFrontOriginAccessIdentityConfigResult, XmlParseError> {
Ok(GetCloudFrontOriginAccessIdentityConfigResult {
cloud_front_origin_access_identity_config: Some(
CloudFrontOriginAccessIdentityConfigDeserializer::deserialize(
"CloudFrontOriginAccessIdentityConfig",
stack,
)?,
),
..GetCloudFrontOriginAccessIdentityConfigResult::default()
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetCloudFrontOriginAccessIdentityRequest {
pub id: String,
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct GetCloudFrontOriginAccessIdentityResult {
pub cloud_front_origin_access_identity: Option<CloudFrontOriginAccessIdentity>,
pub e_tag: Option<String>,
}
#[allow(dead_code)]
struct GetCloudFrontOriginAccessIdentityResultDeserializer;
impl GetCloudFrontOriginAccessIdentityResultDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<GetCloudFrontOriginAccessIdentityResult, XmlParseError> {
Ok(GetCloudFrontOriginAccessIdentityResult {
cloud_front_origin_access_identity: Some(
CloudFrontOriginAccessIdentityDeserializer::deserialize(
"CloudFrontOriginAccessIdentity",
stack,
)?,
),
..GetCloudFrontOriginAccessIdentityResult::default()
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetDistributionConfigRequest {
pub id: String,
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct GetDistributionConfigResult {
pub distribution_config: Option<DistributionConfig>,
pub e_tag: Option<String>,
}
#[allow(dead_code)]
struct GetDistributionConfigResultDeserializer;
impl GetDistributionConfigResultDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<GetDistributionConfigResult, XmlParseError> {
Ok(GetDistributionConfigResult {
distribution_config: Some(DistributionConfigDeserializer::deserialize(
"DistributionConfig",
stack,
)?),
..GetDistributionConfigResult::default()
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetDistributionRequest {
pub id: String,
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct GetDistributionResult {
pub distribution: Option<Distribution>,
pub e_tag: Option<String>,
}
#[allow(dead_code)]
struct GetDistributionResultDeserializer;
impl GetDistributionResultDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<GetDistributionResult, XmlParseError> {
Ok(GetDistributionResult {
distribution: Some(DistributionDeserializer::deserialize(
"Distribution",
stack,
)?),
..GetDistributionResult::default()
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetFieldLevelEncryptionConfigRequest {
pub id: String,
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct GetFieldLevelEncryptionConfigResult {
pub e_tag: Option<String>,
pub field_level_encryption_config: Option<FieldLevelEncryptionConfig>,
}
#[allow(dead_code)]
struct GetFieldLevelEncryptionConfigResultDeserializer;
impl GetFieldLevelEncryptionConfigResultDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<GetFieldLevelEncryptionConfigResult, XmlParseError> {
Ok(GetFieldLevelEncryptionConfigResult {
field_level_encryption_config: Some(
FieldLevelEncryptionConfigDeserializer::deserialize(
"FieldLevelEncryptionConfig",
stack,
)?,
),
..GetFieldLevelEncryptionConfigResult::default()
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetFieldLevelEncryptionProfileConfigRequest {
pub id: String,
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct GetFieldLevelEncryptionProfileConfigResult {
pub e_tag: Option<String>,
pub field_level_encryption_profile_config: Option<FieldLevelEncryptionProfileConfig>,
}
#[allow(dead_code)]
struct GetFieldLevelEncryptionProfileConfigResultDeserializer;
impl GetFieldLevelEncryptionProfileConfigResultDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<GetFieldLevelEncryptionProfileConfigResult, XmlParseError> {
Ok(GetFieldLevelEncryptionProfileConfigResult {
field_level_encryption_profile_config: Some(
FieldLevelEncryptionProfileConfigDeserializer::deserialize(
"FieldLevelEncryptionProfileConfig",
stack,
)?,
),
..GetFieldLevelEncryptionProfileConfigResult::default()
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetFieldLevelEncryptionProfileRequest {
pub id: String,
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct GetFieldLevelEncryptionProfileResult {
pub e_tag: Option<String>,
pub field_level_encryption_profile: Option<FieldLevelEncryptionProfile>,
}
#[allow(dead_code)]
struct GetFieldLevelEncryptionProfileResultDeserializer;
impl GetFieldLevelEncryptionProfileResultDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<GetFieldLevelEncryptionProfileResult, XmlParseError> {
Ok(GetFieldLevelEncryptionProfileResult {
field_level_encryption_profile: Some(
FieldLevelEncryptionProfileDeserializer::deserialize(
"FieldLevelEncryptionProfile",
stack,
)?,
),
..GetFieldLevelEncryptionProfileResult::default()
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetFieldLevelEncryptionRequest {
pub id: String,
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct GetFieldLevelEncryptionResult {
pub e_tag: Option<String>,
pub field_level_encryption: Option<FieldLevelEncryption>,
}
#[allow(dead_code)]
struct GetFieldLevelEncryptionResultDeserializer;
impl GetFieldLevelEncryptionResultDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<GetFieldLevelEncryptionResult, XmlParseError> {
Ok(GetFieldLevelEncryptionResult {
field_level_encryption: Some(FieldLevelEncryptionDeserializer::deserialize(
"FieldLevelEncryption",
stack,
)?),
..GetFieldLevelEncryptionResult::default()
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetInvalidationRequest {
pub distribution_id: String,
pub id: String,
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct GetInvalidationResult {
pub invalidation: Option<Invalidation>,
}
#[allow(dead_code)]
struct GetInvalidationResultDeserializer;
impl GetInvalidationResultDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<GetInvalidationResult, XmlParseError> {
Ok(GetInvalidationResult {
invalidation: Some(InvalidationDeserializer::deserialize(
"Invalidation",
stack,
)?),
..GetInvalidationResult::default()
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetPublicKeyConfigRequest {
pub id: String,
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct GetPublicKeyConfigResult {
pub e_tag: Option<String>,
pub public_key_config: Option<PublicKeyConfig>,
}
#[allow(dead_code)]
struct GetPublicKeyConfigResultDeserializer;
impl GetPublicKeyConfigResultDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<GetPublicKeyConfigResult, XmlParseError> {
Ok(GetPublicKeyConfigResult {
public_key_config: Some(PublicKeyConfigDeserializer::deserialize(
"PublicKeyConfig",
stack,
)?),
..GetPublicKeyConfigResult::default()
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetPublicKeyRequest {
pub id: String,
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct GetPublicKeyResult {
pub e_tag: Option<String>,
pub public_key: Option<PublicKey>,
}
#[allow(dead_code)]
struct GetPublicKeyResultDeserializer;
impl GetPublicKeyResultDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<GetPublicKeyResult, XmlParseError> {
Ok(GetPublicKeyResult {
public_key: Some(PublicKeyDeserializer::deserialize("PublicKey", stack)?),
..GetPublicKeyResult::default()
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetStreamingDistributionConfigRequest {
pub id: String,
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct GetStreamingDistributionConfigResult {
pub e_tag: Option<String>,
pub streaming_distribution_config: Option<StreamingDistributionConfig>,
}
#[allow(dead_code)]
struct GetStreamingDistributionConfigResultDeserializer;
impl GetStreamingDistributionConfigResultDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<GetStreamingDistributionConfigResult, XmlParseError> {
Ok(GetStreamingDistributionConfigResult {
streaming_distribution_config: Some(
StreamingDistributionConfigDeserializer::deserialize(
"StreamingDistributionConfig",
stack,
)?,
),
..GetStreamingDistributionConfigResult::default()
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetStreamingDistributionRequest {
pub id: String,
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct GetStreamingDistributionResult {
pub e_tag: Option<String>,
pub streaming_distribution: Option<StreamingDistribution>,
}
#[allow(dead_code)]
struct GetStreamingDistributionResultDeserializer;
impl GetStreamingDistributionResultDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<GetStreamingDistributionResult, XmlParseError> {
Ok(GetStreamingDistributionResult {
streaming_distribution: Some(StreamingDistributionDeserializer::deserialize(
"StreamingDistribution",
stack,
)?),
..GetStreamingDistributionResult::default()
})
}
}
#[allow(dead_code)]
struct HeaderListDeserializer;
impl HeaderListDeserializer {
#[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 == "Name" {
obj.push(StringDeserializer::deserialize("Name", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
pub struct HeaderListSerializer;
impl HeaderListSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &Vec<String>,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
for element in obj {
StringSerializer::serialize(writer, "Name", element)?;
}
writer.write(xml::writer::XmlEvent::end_element())?;
Ok(())
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct Headers {
pub items: Option<Vec<String>>,
pub quantity: i64,
}
#[allow(dead_code)]
struct HeadersDeserializer;
impl HeadersDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Headers, XmlParseError> {
deserialize_elements::<_, Headers, _>(tag_name, stack, |name, stack, obj| {
match name {
"Items" => {
obj.items
.get_or_insert(vec![])
.extend(HeaderListDeserializer::deserialize("Items", stack)?);
}
"Quantity" => {
obj.quantity = IntegerDeserializer::deserialize("Quantity", stack)?;
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
pub struct HeadersSerializer;
impl HeadersSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &Headers,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
if let Some(ref value) = obj.items {
&HeaderListSerializer::serialize(&mut writer, "Items", value)?;
}
write_characters_element(writer, "Quantity", &obj.quantity.to_string())?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[allow(dead_code)]
struct HttpVersionDeserializer;
impl HttpVersionDeserializer {
#[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)
}
}
pub struct HttpVersionSerializer;
impl HttpVersionSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &String,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
write_characters_element(writer, name, obj)
}
}
#[allow(dead_code)]
struct ICPRecordalStatusDeserializer;
impl ICPRecordalStatusDeserializer {
#[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 IntegerDeserializer;
impl IntegerDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<i64, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, |s| Ok(i64::from_str(&s).unwrap()))
}
}
pub struct IntegerSerializer;
impl IntegerSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &i64,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
write_characters_element(writer, name, &obj.to_string())
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct Invalidation {
pub create_time: String,
pub id: String,
pub invalidation_batch: InvalidationBatch,
pub status: String,
}
#[allow(dead_code)]
struct InvalidationDeserializer;
impl InvalidationDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Invalidation, XmlParseError> {
deserialize_elements::<_, Invalidation, _>(tag_name, stack, |name, stack, obj| {
match name {
"CreateTime" => {
obj.create_time = TimestampDeserializer::deserialize("CreateTime", stack)?;
}
"Id" => {
obj.id = StringDeserializer::deserialize("Id", stack)?;
}
"InvalidationBatch" => {
obj.invalidation_batch =
InvalidationBatchDeserializer::deserialize("InvalidationBatch", stack)?;
}
"Status" => {
obj.status = StringDeserializer::deserialize("Status", stack)?;
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct InvalidationBatch {
pub caller_reference: String,
pub paths: Paths,
}
#[allow(dead_code)]
struct InvalidationBatchDeserializer;
impl InvalidationBatchDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<InvalidationBatch, XmlParseError> {
deserialize_elements::<_, InvalidationBatch, _>(tag_name, stack, |name, stack, obj| {
match name {
"CallerReference" => {
obj.caller_reference =
StringDeserializer::deserialize("CallerReference", stack)?;
}
"Paths" => {
obj.paths = PathsDeserializer::deserialize("Paths", stack)?;
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
pub struct InvalidationBatchSerializer;
impl InvalidationBatchSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &InvalidationBatch,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
write_characters_element(writer, "CallerReference", &obj.caller_reference.to_string())?;
PathsSerializer::serialize(&mut writer, "Paths", &obj.paths)?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct InvalidationList {
pub is_truncated: bool,
pub items: Option<Vec<InvalidationSummary>>,
pub marker: String,
pub max_items: i64,
pub next_marker: Option<String>,
pub quantity: i64,
}
#[allow(dead_code)]
struct InvalidationListDeserializer;
impl InvalidationListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<InvalidationList, XmlParseError> {
deserialize_elements::<_, InvalidationList, _>(tag_name, stack, |name, stack, obj| {
match name {
"IsTruncated" => {
obj.is_truncated = BooleanDeserializer::deserialize("IsTruncated", stack)?;
}
"Items" => {
obj.items.get_or_insert(vec![]).extend(
InvalidationSummaryListDeserializer::deserialize("Items", stack)?,
);
}
"Marker" => {
obj.marker = StringDeserializer::deserialize("Marker", stack)?;
}
"MaxItems" => {
obj.max_items = IntegerDeserializer::deserialize("MaxItems", stack)?;
}
"NextMarker" => {
obj.next_marker = Some(StringDeserializer::deserialize("NextMarker", stack)?);
}
"Quantity" => {
obj.quantity = IntegerDeserializer::deserialize("Quantity", stack)?;
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct InvalidationSummary {
pub create_time: String,
pub id: String,
pub status: String,
}
#[allow(dead_code)]
struct InvalidationSummaryDeserializer;
impl InvalidationSummaryDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<InvalidationSummary, XmlParseError> {
deserialize_elements::<_, InvalidationSummary, _>(tag_name, stack, |name, stack, obj| {
match name {
"CreateTime" => {
obj.create_time = TimestampDeserializer::deserialize("CreateTime", stack)?;
}
"Id" => {
obj.id = StringDeserializer::deserialize("Id", stack)?;
}
"Status" => {
obj.status = StringDeserializer::deserialize("Status", stack)?;
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[allow(dead_code)]
struct InvalidationSummaryListDeserializer;
impl InvalidationSummaryListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<InvalidationSummary>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "InvalidationSummary" {
obj.push(InvalidationSummaryDeserializer::deserialize(
"InvalidationSummary",
stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[allow(dead_code)]
struct ItemSelectionDeserializer;
impl ItemSelectionDeserializer {
#[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)
}
}
pub struct ItemSelectionSerializer;
impl ItemSelectionSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &String,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
write_characters_element(writer, name, obj)
}
}
#[allow(dead_code)]
struct KeyPairIdListDeserializer;
impl KeyPairIdListDeserializer {
#[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 == "KeyPairId" {
obj.push(StringDeserializer::deserialize("KeyPairId", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct KeyPairIds {
pub items: Option<Vec<String>>,
pub quantity: i64,
}
#[allow(dead_code)]
struct KeyPairIdsDeserializer;
impl KeyPairIdsDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<KeyPairIds, XmlParseError> {
deserialize_elements::<_, KeyPairIds, _>(tag_name, stack, |name, stack, obj| {
match name {
"Items" => {
obj.items
.get_or_insert(vec![])
.extend(KeyPairIdListDeserializer::deserialize("Items", stack)?);
}
"Quantity" => {
obj.quantity = IntegerDeserializer::deserialize("Quantity", stack)?;
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[allow(dead_code)]
struct LambdaFunctionARNDeserializer;
impl LambdaFunctionARNDeserializer {
#[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)
}
}
pub struct LambdaFunctionARNSerializer;
impl LambdaFunctionARNSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &String,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
write_characters_element(writer, name, obj)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct LambdaFunctionAssociation {
pub event_type: String,
pub include_body: Option<bool>,
pub lambda_function_arn: String,
}
#[allow(dead_code)]
struct LambdaFunctionAssociationDeserializer;
impl LambdaFunctionAssociationDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<LambdaFunctionAssociation, XmlParseError> {
deserialize_elements::<_, LambdaFunctionAssociation, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"EventType" => {
obj.event_type = EventTypeDeserializer::deserialize("EventType", stack)?;
}
"IncludeBody" => {
obj.include_body =
Some(BooleanDeserializer::deserialize("IncludeBody", stack)?);
}
"LambdaFunctionARN" => {
obj.lambda_function_arn =
LambdaFunctionARNDeserializer::deserialize("LambdaFunctionARN", stack)?;
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
pub struct LambdaFunctionAssociationSerializer;
impl LambdaFunctionAssociationSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &LambdaFunctionAssociation,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
write_characters_element(writer, "EventType", &obj.event_type.to_string())?;
if let Some(ref value) = obj.include_body {
write_characters_element(writer, "IncludeBody", &value.to_string())?;
}
write_characters_element(
writer,
"LambdaFunctionARN",
&obj.lambda_function_arn.to_string(),
)?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[allow(dead_code)]
struct LambdaFunctionAssociationListDeserializer;
impl LambdaFunctionAssociationListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<LambdaFunctionAssociation>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "LambdaFunctionAssociation" {
obj.push(LambdaFunctionAssociationDeserializer::deserialize(
"LambdaFunctionAssociation",
stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
pub struct LambdaFunctionAssociationListSerializer;
impl LambdaFunctionAssociationListSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &Vec<LambdaFunctionAssociation>,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
for element in obj {
LambdaFunctionAssociationSerializer::serialize(
writer,
"LambdaFunctionAssociation",
element,
)?;
}
writer.write(xml::writer::XmlEvent::end_element())?;
Ok(())
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct LambdaFunctionAssociations {
pub items: Option<Vec<LambdaFunctionAssociation>>,
pub quantity: i64,
}
#[allow(dead_code)]
struct LambdaFunctionAssociationsDeserializer;
impl LambdaFunctionAssociationsDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<LambdaFunctionAssociations, XmlParseError> {
deserialize_elements::<_, LambdaFunctionAssociations, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"Items" => {
obj.items.get_or_insert(vec![]).extend(
LambdaFunctionAssociationListDeserializer::deserialize("Items", stack)?,
);
}
"Quantity" => {
obj.quantity = IntegerDeserializer::deserialize("Quantity", stack)?;
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
pub struct LambdaFunctionAssociationsSerializer;
impl LambdaFunctionAssociationsSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &LambdaFunctionAssociations,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
if let Some(ref value) = obj.items {
&LambdaFunctionAssociationListSerializer::serialize(&mut writer, "Items", value)?;
}
write_characters_element(writer, "Quantity", &obj.quantity.to_string())?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListCloudFrontOriginAccessIdentitiesRequest {
pub marker: Option<String>,
pub max_items: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct ListCloudFrontOriginAccessIdentitiesResult {
pub cloud_front_origin_access_identity_list: Option<CloudFrontOriginAccessIdentityList>,
}
#[allow(dead_code)]
struct ListCloudFrontOriginAccessIdentitiesResultDeserializer;
impl ListCloudFrontOriginAccessIdentitiesResultDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ListCloudFrontOriginAccessIdentitiesResult, XmlParseError> {
Ok(ListCloudFrontOriginAccessIdentitiesResult {
cloud_front_origin_access_identity_list: Some(
CloudFrontOriginAccessIdentityListDeserializer::deserialize(
"CloudFrontOriginAccessIdentityList",
stack,
)?,
),
..ListCloudFrontOriginAccessIdentitiesResult::default()
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListDistributionsByWebACLIdRequest {
pub marker: Option<String>,
pub max_items: Option<String>,
pub web_acl_id: String,
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct ListDistributionsByWebACLIdResult {
pub distribution_list: Option<DistributionList>,
}
#[allow(dead_code)]
struct ListDistributionsByWebACLIdResultDeserializer;
impl ListDistributionsByWebACLIdResultDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ListDistributionsByWebACLIdResult, XmlParseError> {
Ok(ListDistributionsByWebACLIdResult {
distribution_list: Some(DistributionListDeserializer::deserialize(
"DistributionList",
stack,
)?),
..ListDistributionsByWebACLIdResult::default()
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListDistributionsRequest {
pub marker: Option<String>,
pub max_items: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct ListDistributionsResult {
pub distribution_list: Option<DistributionList>,
}
#[allow(dead_code)]
struct ListDistributionsResultDeserializer;
impl ListDistributionsResultDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ListDistributionsResult, XmlParseError> {
Ok(ListDistributionsResult {
distribution_list: Some(DistributionListDeserializer::deserialize(
"DistributionList",
stack,
)?),
..ListDistributionsResult::default()
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListFieldLevelEncryptionConfigsRequest {
pub marker: Option<String>,
pub max_items: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct ListFieldLevelEncryptionConfigsResult {
pub field_level_encryption_list: Option<FieldLevelEncryptionList>,
}
#[allow(dead_code)]
struct ListFieldLevelEncryptionConfigsResultDeserializer;
impl ListFieldLevelEncryptionConfigsResultDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ListFieldLevelEncryptionConfigsResult, XmlParseError> {
Ok(ListFieldLevelEncryptionConfigsResult {
field_level_encryption_list: Some(FieldLevelEncryptionListDeserializer::deserialize(
"FieldLevelEncryptionList",
stack,
)?),
..ListFieldLevelEncryptionConfigsResult::default()
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListFieldLevelEncryptionProfilesRequest {
pub marker: Option<String>,
pub max_items: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct ListFieldLevelEncryptionProfilesResult {
pub field_level_encryption_profile_list: Option<FieldLevelEncryptionProfileList>,
}
#[allow(dead_code)]
struct ListFieldLevelEncryptionProfilesResultDeserializer;
impl ListFieldLevelEncryptionProfilesResultDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ListFieldLevelEncryptionProfilesResult, XmlParseError> {
Ok(ListFieldLevelEncryptionProfilesResult {
field_level_encryption_profile_list: Some(
FieldLevelEncryptionProfileListDeserializer::deserialize(
"FieldLevelEncryptionProfileList",
stack,
)?,
),
..ListFieldLevelEncryptionProfilesResult::default()
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListInvalidationsRequest {
pub distribution_id: String,
pub marker: Option<String>,
pub max_items: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct ListInvalidationsResult {
pub invalidation_list: Option<InvalidationList>,
}
#[allow(dead_code)]
struct ListInvalidationsResultDeserializer;
impl ListInvalidationsResultDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ListInvalidationsResult, XmlParseError> {
Ok(ListInvalidationsResult {
invalidation_list: Some(InvalidationListDeserializer::deserialize(
"InvalidationList",
stack,
)?),
..ListInvalidationsResult::default()
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListPublicKeysRequest {
pub marker: Option<String>,
pub max_items: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct ListPublicKeysResult {
pub public_key_list: Option<PublicKeyList>,
}
#[allow(dead_code)]
struct ListPublicKeysResultDeserializer;
impl ListPublicKeysResultDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ListPublicKeysResult, XmlParseError> {
Ok(ListPublicKeysResult {
public_key_list: Some(PublicKeyListDeserializer::deserialize(
"PublicKeyList",
stack,
)?),
..ListPublicKeysResult::default()
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListStreamingDistributionsRequest {
pub marker: Option<String>,
pub max_items: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct ListStreamingDistributionsResult {
pub streaming_distribution_list: Option<StreamingDistributionList>,
}
#[allow(dead_code)]
struct ListStreamingDistributionsResultDeserializer;
impl ListStreamingDistributionsResultDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ListStreamingDistributionsResult, XmlParseError> {
Ok(ListStreamingDistributionsResult {
streaming_distribution_list: Some(StreamingDistributionListDeserializer::deserialize(
"StreamingDistributionList",
stack,
)?),
..ListStreamingDistributionsResult::default()
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListTagsForResourceRequest {
pub resource: String,
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct ListTagsForResourceResult {
pub tags: Tags,
}
#[allow(dead_code)]
struct ListTagsForResourceResultDeserializer;
impl ListTagsForResourceResultDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ListTagsForResourceResult, XmlParseError> {
Ok(ListTagsForResourceResult {
tags: TagsDeserializer::deserialize("Tags", stack)?,
..ListTagsForResourceResult::default()
})
}
}
#[allow(dead_code)]
struct LocationListDeserializer;
impl LocationListDeserializer {
#[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 == "Location" {
obj.push(StringDeserializer::deserialize("Location", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
pub struct LocationListSerializer;
impl LocationListSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &Vec<String>,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
for element in obj {
StringSerializer::serialize(writer, "Location", element)?;
}
writer.write(xml::writer::XmlEvent::end_element())?;
Ok(())
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct LoggingConfig {
pub bucket: String,
pub enabled: bool,
pub include_cookies: bool,
pub prefix: String,
}
#[allow(dead_code)]
struct LoggingConfigDeserializer;
impl LoggingConfigDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<LoggingConfig, XmlParseError> {
deserialize_elements::<_, LoggingConfig, _>(tag_name, stack, |name, stack, obj| {
match name {
"Bucket" => {
obj.bucket = StringDeserializer::deserialize("Bucket", stack)?;
}
"Enabled" => {
obj.enabled = BooleanDeserializer::deserialize("Enabled", stack)?;
}
"IncludeCookies" => {
obj.include_cookies =
BooleanDeserializer::deserialize("IncludeCookies", stack)?;
}
"Prefix" => {
obj.prefix = StringDeserializer::deserialize("Prefix", stack)?;
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
pub struct LoggingConfigSerializer;
impl LoggingConfigSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &LoggingConfig,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
write_characters_element(writer, "Bucket", &obj.bucket.to_string())?;
write_characters_element(writer, "Enabled", &obj.enabled.to_string())?;
write_characters_element(writer, "IncludeCookies", &obj.include_cookies.to_string())?;
write_characters_element(writer, "Prefix", &obj.prefix.to_string())?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[allow(dead_code)]
struct LongDeserializer;
impl LongDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<i64, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, |s| Ok(i64::from_str(&s).unwrap()))
}
}
pub struct LongSerializer;
impl LongSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &i64,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
write_characters_element(writer, name, &obj.to_string())
}
}
#[allow(dead_code)]
struct MethodDeserializer;
impl MethodDeserializer {
#[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)
}
}
pub struct MethodSerializer;
impl MethodSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &String,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
write_characters_element(writer, name, obj)
}
}
#[allow(dead_code)]
struct MethodsListDeserializer;
impl MethodsListDeserializer {
#[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 == "Method" {
obj.push(MethodDeserializer::deserialize("Method", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
pub struct MethodsListSerializer;
impl MethodsListSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &Vec<String>,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
for element in obj {
MethodSerializer::serialize(writer, "Method", element)?;
}
writer.write(xml::writer::XmlEvent::end_element())?;
Ok(())
}
}
#[allow(dead_code)]
struct MinimumProtocolVersionDeserializer;
impl MinimumProtocolVersionDeserializer {
#[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)
}
}
pub struct MinimumProtocolVersionSerializer;
impl MinimumProtocolVersionSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &String,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
write_characters_element(writer, name, obj)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct Origin {
pub connection_attempts: Option<i64>,
pub connection_timeout: Option<i64>,
pub custom_headers: Option<CustomHeaders>,
pub custom_origin_config: Option<CustomOriginConfig>,
pub domain_name: String,
pub id: String,
pub origin_path: Option<String>,
pub s3_origin_config: Option<S3OriginConfig>,
}
#[allow(dead_code)]
struct OriginDeserializer;
impl OriginDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<Origin, XmlParseError> {
deserialize_elements::<_, Origin, _>(tag_name, stack, |name, stack, obj| {
match name {
"ConnectionAttempts" => {
obj.connection_attempts = Some(IntegerDeserializer::deserialize(
"ConnectionAttempts",
stack,
)?);
}
"ConnectionTimeout" => {
obj.connection_timeout = Some(IntegerDeserializer::deserialize(
"ConnectionTimeout",
stack,
)?);
}
"CustomHeaders" => {
obj.custom_headers = Some(CustomHeadersDeserializer::deserialize(
"CustomHeaders",
stack,
)?);
}
"CustomOriginConfig" => {
obj.custom_origin_config = Some(CustomOriginConfigDeserializer::deserialize(
"CustomOriginConfig",
stack,
)?);
}
"DomainName" => {
obj.domain_name = StringDeserializer::deserialize("DomainName", stack)?;
}
"Id" => {
obj.id = StringDeserializer::deserialize("Id", stack)?;
}
"OriginPath" => {
obj.origin_path = Some(StringDeserializer::deserialize("OriginPath", stack)?);
}
"S3OriginConfig" => {
obj.s3_origin_config = Some(S3OriginConfigDeserializer::deserialize(
"S3OriginConfig",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
pub struct OriginSerializer;
impl OriginSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &Origin,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
if let Some(ref value) = obj.connection_attempts {
write_characters_element(writer, "ConnectionAttempts", &value.to_string())?;
}
if let Some(ref value) = obj.connection_timeout {
write_characters_element(writer, "ConnectionTimeout", &value.to_string())?;
}
if let Some(ref value) = obj.custom_headers {
&CustomHeadersSerializer::serialize(&mut writer, "CustomHeaders", value)?;
}
if let Some(ref value) = obj.custom_origin_config {
&CustomOriginConfigSerializer::serialize(&mut writer, "CustomOriginConfig", value)?;
}
write_characters_element(writer, "DomainName", &obj.domain_name.to_string())?;
write_characters_element(writer, "Id", &obj.id.to_string())?;
if let Some(ref value) = obj.origin_path {
write_characters_element(writer, "OriginPath", &value.to_string())?;
}
if let Some(ref value) = obj.s3_origin_config {
&S3OriginConfigSerializer::serialize(&mut writer, "S3OriginConfig", value)?;
}
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct OriginCustomHeader {
pub header_name: String,
pub header_value: String,
}
#[allow(dead_code)]
struct OriginCustomHeaderDeserializer;
impl OriginCustomHeaderDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<OriginCustomHeader, XmlParseError> {
deserialize_elements::<_, OriginCustomHeader, _>(tag_name, stack, |name, stack, obj| {
match name {
"HeaderName" => {
obj.header_name = StringDeserializer::deserialize("HeaderName", stack)?;
}
"HeaderValue" => {
obj.header_value = StringDeserializer::deserialize("HeaderValue", stack)?;
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
pub struct OriginCustomHeaderSerializer;
impl OriginCustomHeaderSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &OriginCustomHeader,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
write_characters_element(writer, "HeaderName", &obj.header_name.to_string())?;
write_characters_element(writer, "HeaderValue", &obj.header_value.to_string())?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[allow(dead_code)]
struct OriginCustomHeadersListDeserializer;
impl OriginCustomHeadersListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<OriginCustomHeader>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "OriginCustomHeader" {
obj.push(OriginCustomHeaderDeserializer::deserialize(
"OriginCustomHeader",
stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
pub struct OriginCustomHeadersListSerializer;
impl OriginCustomHeadersListSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &Vec<OriginCustomHeader>,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
for element in obj {
OriginCustomHeaderSerializer::serialize(writer, "OriginCustomHeader", element)?;
}
writer.write(xml::writer::XmlEvent::end_element())?;
Ok(())
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct OriginGroup {
pub failover_criteria: OriginGroupFailoverCriteria,
pub id: String,
pub members: OriginGroupMembers,
}
#[allow(dead_code)]
struct OriginGroupDeserializer;
impl OriginGroupDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<OriginGroup, XmlParseError> {
deserialize_elements::<_, OriginGroup, _>(tag_name, stack, |name, stack, obj| {
match name {
"FailoverCriteria" => {
obj.failover_criteria = OriginGroupFailoverCriteriaDeserializer::deserialize(
"FailoverCriteria",
stack,
)?;
}
"Id" => {
obj.id = StringDeserializer::deserialize("Id", stack)?;
}
"Members" => {
obj.members = OriginGroupMembersDeserializer::deserialize("Members", stack)?;
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
pub struct OriginGroupSerializer;
impl OriginGroupSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &OriginGroup,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
OriginGroupFailoverCriteriaSerializer::serialize(
&mut writer,
"FailoverCriteria",
&obj.failover_criteria,
)?;
write_characters_element(writer, "Id", &obj.id.to_string())?;
OriginGroupMembersSerializer::serialize(&mut writer, "Members", &obj.members)?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct OriginGroupFailoverCriteria {
pub status_codes: StatusCodes,
}
#[allow(dead_code)]
struct OriginGroupFailoverCriteriaDeserializer;
impl OriginGroupFailoverCriteriaDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<OriginGroupFailoverCriteria, XmlParseError> {
deserialize_elements::<_, OriginGroupFailoverCriteria, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"StatusCodes" => {
obj.status_codes =
StatusCodesDeserializer::deserialize("StatusCodes", stack)?;
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
pub struct OriginGroupFailoverCriteriaSerializer;
impl OriginGroupFailoverCriteriaSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &OriginGroupFailoverCriteria,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
StatusCodesSerializer::serialize(&mut writer, "StatusCodes", &obj.status_codes)?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[allow(dead_code)]
struct OriginGroupListDeserializer;
impl OriginGroupListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<OriginGroup>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "OriginGroup" {
obj.push(OriginGroupDeserializer::deserialize("OriginGroup", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
pub struct OriginGroupListSerializer;
impl OriginGroupListSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &Vec<OriginGroup>,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
for element in obj {
OriginGroupSerializer::serialize(writer, "OriginGroup", element)?;
}
writer.write(xml::writer::XmlEvent::end_element())?;
Ok(())
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct OriginGroupMember {
pub origin_id: String,
}
#[allow(dead_code)]
struct OriginGroupMemberDeserializer;
impl OriginGroupMemberDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<OriginGroupMember, XmlParseError> {
deserialize_elements::<_, OriginGroupMember, _>(tag_name, stack, |name, stack, obj| {
match name {
"OriginId" => {
obj.origin_id = StringDeserializer::deserialize("OriginId", stack)?;
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
pub struct OriginGroupMemberSerializer;
impl OriginGroupMemberSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &OriginGroupMember,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
write_characters_element(writer, "OriginId", &obj.origin_id.to_string())?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[allow(dead_code)]
struct OriginGroupMemberListDeserializer;
impl OriginGroupMemberListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<OriginGroupMember>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "OriginGroupMember" {
obj.push(OriginGroupMemberDeserializer::deserialize(
"OriginGroupMember",
stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
pub struct OriginGroupMemberListSerializer;
impl OriginGroupMemberListSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &Vec<OriginGroupMember>,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
for element in obj {
OriginGroupMemberSerializer::serialize(writer, "OriginGroupMember", element)?;
}
writer.write(xml::writer::XmlEvent::end_element())?;
Ok(())
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct OriginGroupMembers {
pub items: Vec<OriginGroupMember>,
pub quantity: i64,
}
#[allow(dead_code)]
struct OriginGroupMembersDeserializer;
impl OriginGroupMembersDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<OriginGroupMembers, XmlParseError> {
deserialize_elements::<_, OriginGroupMembers, _>(tag_name, stack, |name, stack, obj| {
match name {
"Items" => {
obj.items
.extend(OriginGroupMemberListDeserializer::deserialize(
"Items", stack,
)?);
}
"Quantity" => {
obj.quantity = IntegerDeserializer::deserialize("Quantity", stack)?;
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
pub struct OriginGroupMembersSerializer;
impl OriginGroupMembersSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &OriginGroupMembers,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
OriginGroupMemberListSerializer::serialize(&mut writer, "Items", &obj.items)?;
write_characters_element(writer, "Quantity", &obj.quantity.to_string())?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct OriginGroups {
pub items: Option<Vec<OriginGroup>>,
pub quantity: i64,
}
#[allow(dead_code)]
struct OriginGroupsDeserializer;
impl OriginGroupsDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<OriginGroups, XmlParseError> {
deserialize_elements::<_, OriginGroups, _>(tag_name, stack, |name, stack, obj| {
match name {
"Items" => {
obj.items
.get_or_insert(vec![])
.extend(OriginGroupListDeserializer::deserialize("Items", stack)?);
}
"Quantity" => {
obj.quantity = IntegerDeserializer::deserialize("Quantity", stack)?;
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
pub struct OriginGroupsSerializer;
impl OriginGroupsSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &OriginGroups,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
if let Some(ref value) = obj.items {
&OriginGroupListSerializer::serialize(&mut writer, "Items", value)?;
}
write_characters_element(writer, "Quantity", &obj.quantity.to_string())?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[allow(dead_code)]
struct OriginListDeserializer;
impl OriginListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<Origin>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "Origin" {
obj.push(OriginDeserializer::deserialize("Origin", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
pub struct OriginListSerializer;
impl OriginListSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &Vec<Origin>,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
for element in obj {
OriginSerializer::serialize(writer, "Origin", element)?;
}
writer.write(xml::writer::XmlEvent::end_element())?;
Ok(())
}
}
#[allow(dead_code)]
struct OriginProtocolPolicyDeserializer;
impl OriginProtocolPolicyDeserializer {
#[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)
}
}
pub struct OriginProtocolPolicySerializer;
impl OriginProtocolPolicySerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &String,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
write_characters_element(writer, name, obj)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct OriginSslProtocols {
pub items: Vec<String>,
pub quantity: i64,
}
#[allow(dead_code)]
struct OriginSslProtocolsDeserializer;
impl OriginSslProtocolsDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<OriginSslProtocols, XmlParseError> {
deserialize_elements::<_, OriginSslProtocols, _>(tag_name, stack, |name, stack, obj| {
match name {
"Items" => {
obj.items
.extend(SslProtocolsListDeserializer::deserialize("Items", stack)?);
}
"Quantity" => {
obj.quantity = IntegerDeserializer::deserialize("Quantity", stack)?;
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
pub struct OriginSslProtocolsSerializer;
impl OriginSslProtocolsSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &OriginSslProtocols,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
SslProtocolsListSerializer::serialize(&mut writer, "Items", &obj.items)?;
write_characters_element(writer, "Quantity", &obj.quantity.to_string())?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct Origins {
pub items: Vec<Origin>,
pub quantity: i64,
}
#[allow(dead_code)]
struct OriginsDeserializer;
impl OriginsDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Origins, XmlParseError> {
deserialize_elements::<_, Origins, _>(tag_name, stack, |name, stack, obj| {
match name {
"Items" => {
obj.items
.extend(OriginListDeserializer::deserialize("Items", stack)?);
}
"Quantity" => {
obj.quantity = IntegerDeserializer::deserialize("Quantity", stack)?;
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
pub struct OriginsSerializer;
impl OriginsSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &Origins,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
OriginListSerializer::serialize(&mut writer, "Items", &obj.items)?;
write_characters_element(writer, "Quantity", &obj.quantity.to_string())?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[allow(dead_code)]
struct PathListDeserializer;
impl PathListDeserializer {
#[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 == "Path" {
obj.push(StringDeserializer::deserialize("Path", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
pub struct PathListSerializer;
impl PathListSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &Vec<String>,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
for element in obj {
StringSerializer::serialize(writer, "Path", element)?;
}
writer.write(xml::writer::XmlEvent::end_element())?;
Ok(())
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct Paths {
pub items: Option<Vec<String>>,
pub quantity: i64,
}
#[allow(dead_code)]
struct PathsDeserializer;
impl PathsDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<Paths, XmlParseError> {
deserialize_elements::<_, Paths, _>(tag_name, stack, |name, stack, obj| {
match name {
"Items" => {
obj.items
.get_or_insert(vec![])
.extend(PathListDeserializer::deserialize("Items", stack)?);
}
"Quantity" => {
obj.quantity = IntegerDeserializer::deserialize("Quantity", stack)?;
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
pub struct PathsSerializer;
impl PathsSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &Paths,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
if let Some(ref value) = obj.items {
&PathListSerializer::serialize(&mut writer, "Items", value)?;
}
write_characters_element(writer, "Quantity", &obj.quantity.to_string())?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[allow(dead_code)]
struct PriceClassDeserializer;
impl PriceClassDeserializer {
#[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)
}
}
pub struct PriceClassSerializer;
impl PriceClassSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &String,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
write_characters_element(writer, name, obj)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct PublicKey {
pub created_time: String,
pub id: String,
pub public_key_config: PublicKeyConfig,
}
#[allow(dead_code)]
struct PublicKeyDeserializer;
impl PublicKeyDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<PublicKey, XmlParseError> {
deserialize_elements::<_, PublicKey, _>(tag_name, stack, |name, stack, obj| {
match name {
"CreatedTime" => {
obj.created_time = TimestampDeserializer::deserialize("CreatedTime", stack)?;
}
"Id" => {
obj.id = StringDeserializer::deserialize("Id", stack)?;
}
"PublicKeyConfig" => {
obj.public_key_config =
PublicKeyConfigDeserializer::deserialize("PublicKeyConfig", stack)?;
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct PublicKeyConfig {
pub caller_reference: String,
pub comment: Option<String>,
pub encoded_key: String,
pub name: String,
}
#[allow(dead_code)]
struct PublicKeyConfigDeserializer;
impl PublicKeyConfigDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<PublicKeyConfig, XmlParseError> {
deserialize_elements::<_, PublicKeyConfig, _>(tag_name, stack, |name, stack, obj| {
match name {
"CallerReference" => {
obj.caller_reference =
StringDeserializer::deserialize("CallerReference", stack)?;
}
"Comment" => {
obj.comment = Some(StringDeserializer::deserialize("Comment", stack)?);
}
"EncodedKey" => {
obj.encoded_key = StringDeserializer::deserialize("EncodedKey", stack)?;
}
"Name" => {
obj.name = StringDeserializer::deserialize("Name", stack)?;
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
pub struct PublicKeyConfigSerializer;
impl PublicKeyConfigSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &PublicKeyConfig,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
write_characters_element(writer, "CallerReference", &obj.caller_reference.to_string())?;
if let Some(ref value) = obj.comment {
write_characters_element(writer, "Comment", &value.to_string())?;
}
write_characters_element(writer, "EncodedKey", &obj.encoded_key.to_string())?;
write_characters_element(writer, "Name", &obj.name.to_string())?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct PublicKeyList {
pub items: Option<Vec<PublicKeySummary>>,
pub max_items: i64,
pub next_marker: Option<String>,
pub quantity: i64,
}
#[allow(dead_code)]
struct PublicKeyListDeserializer;
impl PublicKeyListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<PublicKeyList, XmlParseError> {
deserialize_elements::<_, PublicKeyList, _>(tag_name, stack, |name, stack, obj| {
match name {
"Items" => {
obj.items.get_or_insert(vec![]).extend(
PublicKeySummaryListDeserializer::deserialize("Items", stack)?,
);
}
"MaxItems" => {
obj.max_items = IntegerDeserializer::deserialize("MaxItems", stack)?;
}
"NextMarker" => {
obj.next_marker = Some(StringDeserializer::deserialize("NextMarker", stack)?);
}
"Quantity" => {
obj.quantity = IntegerDeserializer::deserialize("Quantity", stack)?;
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct PublicKeySummary {
pub comment: Option<String>,
pub created_time: String,
pub encoded_key: String,
pub id: String,
pub name: String,
}
#[allow(dead_code)]
struct PublicKeySummaryDeserializer;
impl PublicKeySummaryDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<PublicKeySummary, XmlParseError> {
deserialize_elements::<_, PublicKeySummary, _>(tag_name, stack, |name, stack, obj| {
match name {
"Comment" => {
obj.comment = Some(StringDeserializer::deserialize("Comment", stack)?);
}
"CreatedTime" => {
obj.created_time = TimestampDeserializer::deserialize("CreatedTime", stack)?;
}
"EncodedKey" => {
obj.encoded_key = StringDeserializer::deserialize("EncodedKey", stack)?;
}
"Id" => {
obj.id = StringDeserializer::deserialize("Id", stack)?;
}
"Name" => {
obj.name = StringDeserializer::deserialize("Name", stack)?;
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[allow(dead_code)]
struct PublicKeySummaryListDeserializer;
impl PublicKeySummaryListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<PublicKeySummary>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "PublicKeySummary" {
obj.push(PublicKeySummaryDeserializer::deserialize(
"PublicKeySummary",
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 QueryArgProfile {
pub profile_id: String,
pub query_arg: String,
}
#[allow(dead_code)]
struct QueryArgProfileDeserializer;
impl QueryArgProfileDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<QueryArgProfile, XmlParseError> {
deserialize_elements::<_, QueryArgProfile, _>(tag_name, stack, |name, stack, obj| {
match name {
"ProfileId" => {
obj.profile_id = StringDeserializer::deserialize("ProfileId", stack)?;
}
"QueryArg" => {
obj.query_arg = StringDeserializer::deserialize("QueryArg", stack)?;
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
pub struct QueryArgProfileSerializer;
impl QueryArgProfileSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &QueryArgProfile,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
write_characters_element(writer, "ProfileId", &obj.profile_id.to_string())?;
write_characters_element(writer, "QueryArg", &obj.query_arg.to_string())?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct QueryArgProfileConfig {
pub forward_when_query_arg_profile_is_unknown: bool,
pub query_arg_profiles: Option<QueryArgProfiles>,
}
#[allow(dead_code)]
struct QueryArgProfileConfigDeserializer;
impl QueryArgProfileConfigDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<QueryArgProfileConfig, XmlParseError> {
deserialize_elements::<_, QueryArgProfileConfig, _>(tag_name, stack, |name, stack, obj| {
match name {
"ForwardWhenQueryArgProfileIsUnknown" => {
obj.forward_when_query_arg_profile_is_unknown =
BooleanDeserializer::deserialize(
"ForwardWhenQueryArgProfileIsUnknown",
stack,
)?;
}
"QueryArgProfiles" => {
obj.query_arg_profiles = Some(QueryArgProfilesDeserializer::deserialize(
"QueryArgProfiles",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
pub struct QueryArgProfileConfigSerializer;
impl QueryArgProfileConfigSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &QueryArgProfileConfig,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
write_characters_element(
writer,
"ForwardWhenQueryArgProfileIsUnknown",
&obj.forward_when_query_arg_profile_is_unknown.to_string(),
)?;
if let Some(ref value) = obj.query_arg_profiles {
&QueryArgProfilesSerializer::serialize(&mut writer, "QueryArgProfiles", value)?;
}
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[allow(dead_code)]
struct QueryArgProfileListDeserializer;
impl QueryArgProfileListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<QueryArgProfile>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "QueryArgProfile" {
obj.push(QueryArgProfileDeserializer::deserialize(
"QueryArgProfile",
stack,
)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
pub struct QueryArgProfileListSerializer;
impl QueryArgProfileListSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &Vec<QueryArgProfile>,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
for element in obj {
QueryArgProfileSerializer::serialize(writer, "QueryArgProfile", element)?;
}
writer.write(xml::writer::XmlEvent::end_element())?;
Ok(())
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct QueryArgProfiles {
pub items: Option<Vec<QueryArgProfile>>,
pub quantity: i64,
}
#[allow(dead_code)]
struct QueryArgProfilesDeserializer;
impl QueryArgProfilesDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<QueryArgProfiles, XmlParseError> {
deserialize_elements::<_, QueryArgProfiles, _>(tag_name, stack, |name, stack, obj| {
match name {
"Items" => {
obj.items.get_or_insert(vec![]).extend(
QueryArgProfileListDeserializer::deserialize("Items", stack)?,
);
}
"Quantity" => {
obj.quantity = IntegerDeserializer::deserialize("Quantity", stack)?;
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
pub struct QueryArgProfilesSerializer;
impl QueryArgProfilesSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &QueryArgProfiles,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
if let Some(ref value) = obj.items {
&QueryArgProfileListSerializer::serialize(&mut writer, "Items", value)?;
}
write_characters_element(writer, "Quantity", &obj.quantity.to_string())?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct QueryStringCacheKeys {
pub items: Option<Vec<String>>,
pub quantity: i64,
}
#[allow(dead_code)]
struct QueryStringCacheKeysDeserializer;
impl QueryStringCacheKeysDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<QueryStringCacheKeys, XmlParseError> {
deserialize_elements::<_, QueryStringCacheKeys, _>(tag_name, stack, |name, stack, obj| {
match name {
"Items" => {
obj.items.get_or_insert(vec![]).extend(
QueryStringCacheKeysListDeserializer::deserialize("Items", stack)?,
);
}
"Quantity" => {
obj.quantity = IntegerDeserializer::deserialize("Quantity", stack)?;
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
pub struct QueryStringCacheKeysSerializer;
impl QueryStringCacheKeysSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &QueryStringCacheKeys,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
if let Some(ref value) = obj.items {
&QueryStringCacheKeysListSerializer::serialize(&mut writer, "Items", value)?;
}
write_characters_element(writer, "Quantity", &obj.quantity.to_string())?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[allow(dead_code)]
struct QueryStringCacheKeysListDeserializer;
impl QueryStringCacheKeysListDeserializer {
#[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 == "Name" {
obj.push(StringDeserializer::deserialize("Name", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
pub struct QueryStringCacheKeysListSerializer;
impl QueryStringCacheKeysListSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &Vec<String>,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
for element in obj {
StringSerializer::serialize(writer, "Name", element)?;
}
writer.write(xml::writer::XmlEvent::end_element())?;
Ok(())
}
}
pub struct ResourceARNSerializer;
impl ResourceARNSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &String,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
write_characters_element(writer, name, obj)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct Restrictions {
pub geo_restriction: GeoRestriction,
}
#[allow(dead_code)]
struct RestrictionsDeserializer;
impl RestrictionsDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Restrictions, XmlParseError> {
deserialize_elements::<_, Restrictions, _>(tag_name, stack, |name, stack, obj| {
match name {
"GeoRestriction" => {
obj.geo_restriction =
GeoRestrictionDeserializer::deserialize("GeoRestriction", stack)?;
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
pub struct RestrictionsSerializer;
impl RestrictionsSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &Restrictions,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
GeoRestrictionSerializer::serialize(&mut writer, "GeoRestriction", &obj.geo_restriction)?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct S3Origin {
pub domain_name: String,
pub origin_access_identity: String,
}
#[allow(dead_code)]
struct S3OriginDeserializer;
impl S3OriginDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<S3Origin, XmlParseError> {
deserialize_elements::<_, S3Origin, _>(tag_name, stack, |name, stack, obj| {
match name {
"DomainName" => {
obj.domain_name = StringDeserializer::deserialize("DomainName", stack)?;
}
"OriginAccessIdentity" => {
obj.origin_access_identity =
StringDeserializer::deserialize("OriginAccessIdentity", stack)?;
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
pub struct S3OriginSerializer;
impl S3OriginSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &S3Origin,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
write_characters_element(writer, "DomainName", &obj.domain_name.to_string())?;
write_characters_element(
writer,
"OriginAccessIdentity",
&obj.origin_access_identity.to_string(),
)?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct S3OriginConfig {
pub origin_access_identity: String,
}
#[allow(dead_code)]
struct S3OriginConfigDeserializer;
impl S3OriginConfigDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<S3OriginConfig, XmlParseError> {
deserialize_elements::<_, S3OriginConfig, _>(tag_name, stack, |name, stack, obj| {
match name {
"OriginAccessIdentity" => {
obj.origin_access_identity =
StringDeserializer::deserialize("OriginAccessIdentity", stack)?;
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
pub struct S3OriginConfigSerializer;
impl S3OriginConfigSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &S3OriginConfig,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
write_characters_element(
writer,
"OriginAccessIdentity",
&obj.origin_access_identity.to_string(),
)?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[allow(dead_code)]
struct SSLSupportMethodDeserializer;
impl SSLSupportMethodDeserializer {
#[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)
}
}
pub struct SSLSupportMethodSerializer;
impl SSLSupportMethodSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &String,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
write_characters_element(writer, name, obj)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct Signer {
pub aws_account_number: Option<String>,
pub key_pair_ids: Option<KeyPairIds>,
}
#[allow(dead_code)]
struct SignerDeserializer;
impl SignerDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<Signer, XmlParseError> {
deserialize_elements::<_, Signer, _>(tag_name, stack, |name, stack, obj| {
match name {
"AwsAccountNumber" => {
obj.aws_account_number =
Some(StringDeserializer::deserialize("AwsAccountNumber", stack)?);
}
"KeyPairIds" => {
obj.key_pair_ids =
Some(KeyPairIdsDeserializer::deserialize("KeyPairIds", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[allow(dead_code)]
struct SignerListDeserializer;
impl SignerListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<Signer>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "Signer" {
obj.push(SignerDeserializer::deserialize("Signer", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
#[allow(dead_code)]
struct SslProtocolDeserializer;
impl SslProtocolDeserializer {
#[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)
}
}
pub struct SslProtocolSerializer;
impl SslProtocolSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &String,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
write_characters_element(writer, name, obj)
}
}
#[allow(dead_code)]
struct SslProtocolsListDeserializer;
impl SslProtocolsListDeserializer {
#[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 == "SslProtocol" {
obj.push(SslProtocolDeserializer::deserialize("SslProtocol", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
pub struct SslProtocolsListSerializer;
impl SslProtocolsListSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &Vec<String>,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
for element in obj {
SslProtocolSerializer::serialize(writer, "SslProtocol", element)?;
}
writer.write(xml::writer::XmlEvent::end_element())?;
Ok(())
}
}
#[allow(dead_code)]
struct StatusCodeListDeserializer;
impl StatusCodeListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<i64>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "StatusCode" {
obj.push(IntegerDeserializer::deserialize("StatusCode", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
pub struct StatusCodeListSerializer;
impl StatusCodeListSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &Vec<i64>,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
for element in obj {
IntegerSerializer::serialize(writer, "StatusCode", element)?;
}
writer.write(xml::writer::XmlEvent::end_element())?;
Ok(())
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct StatusCodes {
pub items: Vec<i64>,
pub quantity: i64,
}
#[allow(dead_code)]
struct StatusCodesDeserializer;
impl StatusCodesDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<StatusCodes, XmlParseError> {
deserialize_elements::<_, StatusCodes, _>(tag_name, stack, |name, stack, obj| {
match name {
"Items" => {
obj.items
.extend(StatusCodeListDeserializer::deserialize("Items", stack)?);
}
"Quantity" => {
obj.quantity = IntegerDeserializer::deserialize("Quantity", stack)?;
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
pub struct StatusCodesSerializer;
impl StatusCodesSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &StatusCodes,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
StatusCodeListSerializer::serialize(&mut writer, "Items", &obj.items)?;
write_characters_element(writer, "Quantity", &obj.quantity.to_string())?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct StreamingDistribution {
pub arn: String,
pub active_trusted_signers: ActiveTrustedSigners,
pub domain_name: String,
pub id: String,
pub last_modified_time: Option<String>,
pub status: String,
pub streaming_distribution_config: StreamingDistributionConfig,
}
#[allow(dead_code)]
struct StreamingDistributionDeserializer;
impl StreamingDistributionDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<StreamingDistribution, XmlParseError> {
deserialize_elements::<_, StreamingDistribution, _>(tag_name, stack, |name, stack, obj| {
match name {
"ARN" => {
obj.arn = StringDeserializer::deserialize("ARN", stack)?;
}
"ActiveTrustedSigners" => {
obj.active_trusted_signers = ActiveTrustedSignersDeserializer::deserialize(
"ActiveTrustedSigners",
stack,
)?;
}
"DomainName" => {
obj.domain_name = StringDeserializer::deserialize("DomainName", stack)?;
}
"Id" => {
obj.id = StringDeserializer::deserialize("Id", stack)?;
}
"LastModifiedTime" => {
obj.last_modified_time = Some(TimestampDeserializer::deserialize(
"LastModifiedTime",
stack,
)?);
}
"Status" => {
obj.status = StringDeserializer::deserialize("Status", stack)?;
}
"StreamingDistributionConfig" => {
obj.streaming_distribution_config =
StreamingDistributionConfigDeserializer::deserialize(
"StreamingDistributionConfig",
stack,
)?;
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct StreamingDistributionConfig {
pub aliases: Option<Aliases>,
pub caller_reference: String,
pub comment: String,
pub enabled: bool,
pub logging: Option<StreamingLoggingConfig>,
pub price_class: Option<String>,
pub s3_origin: S3Origin,
pub trusted_signers: TrustedSigners,
}
#[allow(dead_code)]
struct StreamingDistributionConfigDeserializer;
impl StreamingDistributionConfigDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<StreamingDistributionConfig, XmlParseError> {
deserialize_elements::<_, StreamingDistributionConfig, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"Aliases" => {
obj.aliases = Some(AliasesDeserializer::deserialize("Aliases", stack)?);
}
"CallerReference" => {
obj.caller_reference =
StringDeserializer::deserialize("CallerReference", stack)?;
}
"Comment" => {
obj.comment = StringDeserializer::deserialize("Comment", stack)?;
}
"Enabled" => {
obj.enabled = BooleanDeserializer::deserialize("Enabled", stack)?;
}
"Logging" => {
obj.logging = Some(StreamingLoggingConfigDeserializer::deserialize(
"Logging", stack,
)?);
}
"PriceClass" => {
obj.price_class =
Some(PriceClassDeserializer::deserialize("PriceClass", stack)?);
}
"S3Origin" => {
obj.s3_origin = S3OriginDeserializer::deserialize("S3Origin", stack)?;
}
"TrustedSigners" => {
obj.trusted_signers =
TrustedSignersDeserializer::deserialize("TrustedSigners", stack)?;
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
pub struct StreamingDistributionConfigSerializer;
impl StreamingDistributionConfigSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &StreamingDistributionConfig,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
if let Some(ref value) = obj.aliases {
&AliasesSerializer::serialize(&mut writer, "Aliases", value)?;
}
write_characters_element(writer, "CallerReference", &obj.caller_reference.to_string())?;
write_characters_element(writer, "Comment", &obj.comment.to_string())?;
write_characters_element(writer, "Enabled", &obj.enabled.to_string())?;
if let Some(ref value) = obj.logging {
&StreamingLoggingConfigSerializer::serialize(&mut writer, "Logging", value)?;
}
if let Some(ref value) = obj.price_class {
write_characters_element(writer, "PriceClass", &value.to_string())?;
}
S3OriginSerializer::serialize(&mut writer, "S3Origin", &obj.s3_origin)?;
TrustedSignersSerializer::serialize(&mut writer, "TrustedSigners", &obj.trusted_signers)?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct StreamingDistributionConfigWithTags {
pub streaming_distribution_config: StreamingDistributionConfig,
pub tags: Tags,
}
pub struct StreamingDistributionConfigWithTagsSerializer;
impl StreamingDistributionConfigWithTagsSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &StreamingDistributionConfigWithTags,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
StreamingDistributionConfigSerializer::serialize(
&mut writer,
"StreamingDistributionConfig",
&obj.streaming_distribution_config,
)?;
TagsSerializer::serialize(&mut writer, "Tags", &obj.tags)?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct StreamingDistributionList {
pub is_truncated: bool,
pub items: Option<Vec<StreamingDistributionSummary>>,
pub marker: String,
pub max_items: i64,
pub next_marker: Option<String>,
pub quantity: i64,
}
#[allow(dead_code)]
struct StreamingDistributionListDeserializer;
impl StreamingDistributionListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<StreamingDistributionList, XmlParseError> {
deserialize_elements::<_, StreamingDistributionList, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"IsTruncated" => {
obj.is_truncated = BooleanDeserializer::deserialize("IsTruncated", stack)?;
}
"Items" => {
obj.items.get_or_insert(vec![]).extend(
StreamingDistributionSummaryListDeserializer::deserialize(
"Items", stack,
)?,
);
}
"Marker" => {
obj.marker = StringDeserializer::deserialize("Marker", stack)?;
}
"MaxItems" => {
obj.max_items = IntegerDeserializer::deserialize("MaxItems", stack)?;
}
"NextMarker" => {
obj.next_marker =
Some(StringDeserializer::deserialize("NextMarker", stack)?);
}
"Quantity" => {
obj.quantity = IntegerDeserializer::deserialize("Quantity", stack)?;
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct StreamingDistributionSummary {
pub arn: String,
pub aliases: Aliases,
pub comment: String,
pub domain_name: String,
pub enabled: bool,
pub id: String,
pub last_modified_time: String,
pub price_class: String,
pub s3_origin: S3Origin,
pub status: String,
pub trusted_signers: TrustedSigners,
}
#[allow(dead_code)]
struct StreamingDistributionSummaryDeserializer;
impl StreamingDistributionSummaryDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<StreamingDistributionSummary, XmlParseError> {
deserialize_elements::<_, StreamingDistributionSummary, _>(
tag_name,
stack,
|name, stack, obj| {
match name {
"ARN" => {
obj.arn = StringDeserializer::deserialize("ARN", stack)?;
}
"Aliases" => {
obj.aliases = AliasesDeserializer::deserialize("Aliases", stack)?;
}
"Comment" => {
obj.comment = StringDeserializer::deserialize("Comment", stack)?;
}
"DomainName" => {
obj.domain_name = StringDeserializer::deserialize("DomainName", stack)?;
}
"Enabled" => {
obj.enabled = BooleanDeserializer::deserialize("Enabled", stack)?;
}
"Id" => {
obj.id = StringDeserializer::deserialize("Id", stack)?;
}
"LastModifiedTime" => {
obj.last_modified_time =
TimestampDeserializer::deserialize("LastModifiedTime", stack)?;
}
"PriceClass" => {
obj.price_class = PriceClassDeserializer::deserialize("PriceClass", stack)?;
}
"S3Origin" => {
obj.s3_origin = S3OriginDeserializer::deserialize("S3Origin", stack)?;
}
"Status" => {
obj.status = StringDeserializer::deserialize("Status", stack)?;
}
"TrustedSigners" => {
obj.trusted_signers =
TrustedSignersDeserializer::deserialize("TrustedSigners", stack)?;
}
_ => skip_tree(stack),
}
Ok(())
},
)
}
}
#[allow(dead_code)]
struct StreamingDistributionSummaryListDeserializer;
impl StreamingDistributionSummaryListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<StreamingDistributionSummary>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "StreamingDistributionSummary" {
obj.push(StreamingDistributionSummaryDeserializer::deserialize(
"StreamingDistributionSummary",
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 StreamingLoggingConfig {
pub bucket: String,
pub enabled: bool,
pub prefix: String,
}
#[allow(dead_code)]
struct StreamingLoggingConfigDeserializer;
impl StreamingLoggingConfigDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<StreamingLoggingConfig, XmlParseError> {
deserialize_elements::<_, StreamingLoggingConfig, _>(tag_name, stack, |name, stack, obj| {
match name {
"Bucket" => {
obj.bucket = StringDeserializer::deserialize("Bucket", stack)?;
}
"Enabled" => {
obj.enabled = BooleanDeserializer::deserialize("Enabled", stack)?;
}
"Prefix" => {
obj.prefix = StringDeserializer::deserialize("Prefix", stack)?;
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
pub struct StreamingLoggingConfigSerializer;
impl StreamingLoggingConfigSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &StreamingLoggingConfig,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
write_characters_element(writer, "Bucket", &obj.bucket.to_string())?;
write_characters_element(writer, "Enabled", &obj.enabled.to_string())?;
write_characters_element(writer, "Prefix", &obj.prefix.to_string())?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[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)
}
}
pub struct StringSerializer;
impl StringSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &String,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
write_characters_element(writer, name, obj)
}
}
#[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: Option<String>,
}
#[allow(dead_code)]
struct TagDeserializer;
impl TagDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<Tag, XmlParseError> {
deserialize_elements::<_, Tag, _>(tag_name, stack, |name, stack, obj| {
match name {
"Key" => {
obj.key = TagKeyDeserializer::deserialize("Key", stack)?;
}
"Value" => {
obj.value = Some(TagValueDeserializer::deserialize("Value", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
pub struct TagSerializer;
impl TagSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &Tag,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
write_characters_element(writer, "Key", &obj.key.to_string())?;
if let Some(ref value) = obj.value {
write_characters_element(writer, "Value", &value.to_string())?;
}
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[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)
}
}
pub struct TagKeySerializer;
impl TagKeySerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &String,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
write_characters_element(writer, name, obj)
}
}
pub struct TagKeyListSerializer;
impl TagKeyListSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &Vec<String>,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
for element in obj {
TagKeySerializer::serialize(writer, "Key", element)?;
}
writer.write(xml::writer::XmlEvent::end_element())?;
Ok(())
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct TagKeys {
pub items: Option<Vec<String>>,
}
pub struct TagKeysSerializer;
impl TagKeysSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &TagKeys,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
if let Some(ref value) = obj.items {
&TagKeyListSerializer::serialize(&mut writer, "Items", value)?;
}
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[allow(dead_code)]
struct TagListDeserializer;
impl TagListDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<Tag>, XmlParseError> {
deserialize_elements::<_, Vec<_>, _>(tag_name, stack, |name, stack, obj| {
if name == "Tag" {
obj.push(TagDeserializer::deserialize("Tag", stack)?);
} else {
skip_tree(stack);
}
Ok(())
})
}
}
pub struct TagListSerializer;
impl TagListSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &Vec<Tag>,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
for element in obj {
TagSerializer::serialize(writer, "Tag", element)?;
}
writer.write(xml::writer::XmlEvent::end_element())?;
Ok(())
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct TagResourceRequest {
pub resource: String,
pub tags: Tags,
}
#[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)
}
}
pub struct TagValueSerializer;
impl TagValueSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &String,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
write_characters_element(writer, name, obj)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct Tags {
pub items: Option<Vec<Tag>>,
}
#[allow(dead_code)]
struct TagsDeserializer;
impl TagsDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<Tags, XmlParseError> {
deserialize_elements::<_, Tags, _>(tag_name, stack, |name, stack, obj| {
match name {
"Items" => {
obj.items
.get_or_insert(vec![])
.extend(TagListDeserializer::deserialize("Items", stack)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
pub struct TagsSerializer;
impl TagsSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &Tags,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
if let Some(ref value) = obj.items {
&TagListSerializer::serialize(&mut writer, "Items", value)?;
}
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[allow(dead_code)]
struct TimestampDeserializer;
impl TimestampDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(tag_name: &str, stack: &mut T) -> Result<String, XmlParseError> {
xml_util::deserialize_primitive(tag_name, stack, Ok)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct TrustedSigners {
pub enabled: bool,
pub items: Option<Vec<String>>,
pub quantity: i64,
}
#[allow(dead_code)]
struct TrustedSignersDeserializer;
impl TrustedSignersDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<TrustedSigners, XmlParseError> {
deserialize_elements::<_, TrustedSigners, _>(tag_name, stack, |name, stack, obj| {
match name {
"Enabled" => {
obj.enabled = BooleanDeserializer::deserialize("Enabled", stack)?;
}
"Items" => {
obj.items.get_or_insert(vec![]).extend(
AwsAccountNumberListDeserializer::deserialize("Items", stack)?,
);
}
"Quantity" => {
obj.quantity = IntegerDeserializer::deserialize("Quantity", stack)?;
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
pub struct TrustedSignersSerializer;
impl TrustedSignersSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &TrustedSigners,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
write_characters_element(writer, "Enabled", &obj.enabled.to_string())?;
if let Some(ref value) = obj.items {
&AwsAccountNumberListSerializer::serialize(&mut writer, "Items", value)?;
}
write_characters_element(writer, "Quantity", &obj.quantity.to_string())?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UntagResourceRequest {
pub resource: String,
pub tag_keys: TagKeys,
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateCloudFrontOriginAccessIdentityRequest {
pub cloud_front_origin_access_identity_config: CloudFrontOriginAccessIdentityConfig,
pub id: String,
pub if_match: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct UpdateCloudFrontOriginAccessIdentityResult {
pub cloud_front_origin_access_identity: Option<CloudFrontOriginAccessIdentity>,
pub e_tag: Option<String>,
}
#[allow(dead_code)]
struct UpdateCloudFrontOriginAccessIdentityResultDeserializer;
impl UpdateCloudFrontOriginAccessIdentityResultDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<UpdateCloudFrontOriginAccessIdentityResult, XmlParseError> {
Ok(UpdateCloudFrontOriginAccessIdentityResult {
cloud_front_origin_access_identity: Some(
CloudFrontOriginAccessIdentityDeserializer::deserialize(
"CloudFrontOriginAccessIdentity",
stack,
)?,
),
..UpdateCloudFrontOriginAccessIdentityResult::default()
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateDistributionRequest {
pub distribution_config: DistributionConfig,
pub id: String,
pub if_match: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct UpdateDistributionResult {
pub distribution: Option<Distribution>,
pub e_tag: Option<String>,
}
#[allow(dead_code)]
struct UpdateDistributionResultDeserializer;
impl UpdateDistributionResultDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<UpdateDistributionResult, XmlParseError> {
Ok(UpdateDistributionResult {
distribution: Some(DistributionDeserializer::deserialize(
"Distribution",
stack,
)?),
..UpdateDistributionResult::default()
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateFieldLevelEncryptionConfigRequest {
pub field_level_encryption_config: FieldLevelEncryptionConfig,
pub id: String,
pub if_match: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct UpdateFieldLevelEncryptionConfigResult {
pub e_tag: Option<String>,
pub field_level_encryption: Option<FieldLevelEncryption>,
}
#[allow(dead_code)]
struct UpdateFieldLevelEncryptionConfigResultDeserializer;
impl UpdateFieldLevelEncryptionConfigResultDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<UpdateFieldLevelEncryptionConfigResult, XmlParseError> {
Ok(UpdateFieldLevelEncryptionConfigResult {
field_level_encryption: Some(FieldLevelEncryptionDeserializer::deserialize(
"FieldLevelEncryption",
stack,
)?),
..UpdateFieldLevelEncryptionConfigResult::default()
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateFieldLevelEncryptionProfileRequest {
pub field_level_encryption_profile_config: FieldLevelEncryptionProfileConfig,
pub id: String,
pub if_match: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct UpdateFieldLevelEncryptionProfileResult {
pub e_tag: Option<String>,
pub field_level_encryption_profile: Option<FieldLevelEncryptionProfile>,
}
#[allow(dead_code)]
struct UpdateFieldLevelEncryptionProfileResultDeserializer;
impl UpdateFieldLevelEncryptionProfileResultDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<UpdateFieldLevelEncryptionProfileResult, XmlParseError> {
Ok(UpdateFieldLevelEncryptionProfileResult {
field_level_encryption_profile: Some(
FieldLevelEncryptionProfileDeserializer::deserialize(
"FieldLevelEncryptionProfile",
stack,
)?,
),
..UpdateFieldLevelEncryptionProfileResult::default()
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdatePublicKeyRequest {
pub id: String,
pub if_match: Option<String>,
pub public_key_config: PublicKeyConfig,
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct UpdatePublicKeyResult {
pub e_tag: Option<String>,
pub public_key: Option<PublicKey>,
}
#[allow(dead_code)]
struct UpdatePublicKeyResultDeserializer;
impl UpdatePublicKeyResultDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<UpdatePublicKeyResult, XmlParseError> {
Ok(UpdatePublicKeyResult {
public_key: Some(PublicKeyDeserializer::deserialize("PublicKey", stack)?),
..UpdatePublicKeyResult::default()
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateStreamingDistributionRequest {
pub id: String,
pub if_match: Option<String>,
pub streaming_distribution_config: StreamingDistributionConfig,
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
pub struct UpdateStreamingDistributionResult {
pub e_tag: Option<String>,
pub streaming_distribution: Option<StreamingDistribution>,
}
#[allow(dead_code)]
struct UpdateStreamingDistributionResultDeserializer;
impl UpdateStreamingDistributionResultDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<UpdateStreamingDistributionResult, XmlParseError> {
Ok(UpdateStreamingDistributionResult {
streaming_distribution: Some(StreamingDistributionDeserializer::deserialize(
"StreamingDistribution",
stack,
)?),
..UpdateStreamingDistributionResult::default()
})
}
}
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serialize_structs", derive(Serialize))]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ViewerCertificate {
pub acm_certificate_arn: Option<String>,
pub cloud_front_default_certificate: Option<bool>,
pub iam_certificate_id: Option<String>,
pub minimum_protocol_version: Option<String>,
pub ssl_support_method: Option<String>,
}
#[allow(dead_code)]
struct ViewerCertificateDeserializer;
impl ViewerCertificateDeserializer {
#[allow(dead_code, unused_variables)]
fn deserialize<T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ViewerCertificate, XmlParseError> {
deserialize_elements::<_, ViewerCertificate, _>(tag_name, stack, |name, stack, obj| {
match name {
"ACMCertificateArn" => {
obj.acm_certificate_arn =
Some(StringDeserializer::deserialize("ACMCertificateArn", stack)?);
}
"CloudFrontDefaultCertificate" => {
obj.cloud_front_default_certificate = Some(BooleanDeserializer::deserialize(
"CloudFrontDefaultCertificate",
stack,
)?);
}
"IAMCertificateId" => {
obj.iam_certificate_id =
Some(StringDeserializer::deserialize("IAMCertificateId", stack)?);
}
"MinimumProtocolVersion" => {
obj.minimum_protocol_version =
Some(MinimumProtocolVersionDeserializer::deserialize(
"MinimumProtocolVersion",
stack,
)?);
}
"SSLSupportMethod" => {
obj.ssl_support_method = Some(SSLSupportMethodDeserializer::deserialize(
"SSLSupportMethod",
stack,
)?);
}
_ => skip_tree(stack),
}
Ok(())
})
}
}
pub struct ViewerCertificateSerializer;
impl ViewerCertificateSerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &ViewerCertificate,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
if let Some(ref value) = obj.acm_certificate_arn {
write_characters_element(writer, "ACMCertificateArn", &value.to_string())?;
}
if let Some(ref value) = obj.cloud_front_default_certificate {
write_characters_element(writer, "CloudFrontDefaultCertificate", &value.to_string())?;
}
if let Some(ref value) = obj.iam_certificate_id {
write_characters_element(writer, "IAMCertificateId", &value.to_string())?;
}
if let Some(ref value) = obj.minimum_protocol_version {
write_characters_element(writer, "MinimumProtocolVersion", &value.to_string())?;
}
if let Some(ref value) = obj.ssl_support_method {
write_characters_element(writer, "SSLSupportMethod", &value.to_string())?;
}
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[allow(dead_code)]
struct ViewerProtocolPolicyDeserializer;
impl ViewerProtocolPolicyDeserializer {
#[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)
}
}
pub struct ViewerProtocolPolicySerializer;
impl ViewerProtocolPolicySerializer {
#[allow(unused_variables, warnings)]
pub fn serialize<W>(
mut writer: &mut EventWriter<W>,
name: &str,
obj: &String,
) -> Result<(), xml::writer::Error>
where
W: Write,
{
write_characters_element(writer, name, obj)
}
}
#[derive(Debug, PartialEq)]
pub enum CreateCloudFrontOriginAccessIdentityError {
CloudFrontOriginAccessIdentityAlreadyExists(String),
InconsistentQuantities(String),
InvalidArgument(String),
MissingBody(String),
TooManyCloudFrontOriginAccessIdentities(String),
}
impl CreateCloudFrontOriginAccessIdentityError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<CreateCloudFrontOriginAccessIdentityError> {
{
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[..] {
"CloudFrontOriginAccessIdentityAlreadyExists" => return RusotoError::Service(CreateCloudFrontOriginAccessIdentityError::CloudFrontOriginAccessIdentityAlreadyExists(parsed_error.message)),"InconsistentQuantities" => return RusotoError::Service(CreateCloudFrontOriginAccessIdentityError::InconsistentQuantities(parsed_error.message)),"InvalidArgument" => return RusotoError::Service(CreateCloudFrontOriginAccessIdentityError::InvalidArgument(parsed_error.message)),"MissingBody" => return RusotoError::Service(CreateCloudFrontOriginAccessIdentityError::MissingBody(parsed_error.message)),"TooManyCloudFrontOriginAccessIdentities" => return RusotoError::Service(CreateCloudFrontOriginAccessIdentityError::TooManyCloudFrontOriginAccessIdentities(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 CreateCloudFrontOriginAccessIdentityError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateCloudFrontOriginAccessIdentityError::CloudFrontOriginAccessIdentityAlreadyExists(ref cause) => write!(f, "{}", cause),
CreateCloudFrontOriginAccessIdentityError::InconsistentQuantities(ref cause) => write!(f, "{}", cause),
CreateCloudFrontOriginAccessIdentityError::InvalidArgument(ref cause) => write!(f, "{}", cause),
CreateCloudFrontOriginAccessIdentityError::MissingBody(ref cause) => write!(f, "{}", cause),
CreateCloudFrontOriginAccessIdentityError::TooManyCloudFrontOriginAccessIdentities(ref cause) => write!(f, "{}", cause)
}
}
}
impl Error for CreateCloudFrontOriginAccessIdentityError {}
#[derive(Debug, PartialEq)]
pub enum CreateDistributionError {
AccessDenied(String),
CNAMEAlreadyExists(String),
DistributionAlreadyExists(String),
IllegalFieldLevelEncryptionConfigAssociationWithCacheBehavior(String),
InconsistentQuantities(String),
InvalidArgument(String),
InvalidDefaultRootObject(String),
InvalidErrorCode(String),
InvalidForwardCookies(String),
InvalidGeoRestrictionParameter(String),
InvalidHeadersForS3Origin(String),
InvalidLambdaFunctionAssociation(String),
InvalidLocationCode(String),
InvalidMinimumProtocolVersion(String),
InvalidOrigin(String),
InvalidOriginAccessIdentity(String),
InvalidOriginKeepaliveTimeout(String),
InvalidOriginReadTimeout(String),
InvalidProtocolSettings(String),
InvalidQueryStringParameters(String),
InvalidRelativePath(String),
InvalidRequiredProtocol(String),
InvalidResponseCode(String),
InvalidTTLOrder(String),
InvalidViewerCertificate(String),
InvalidWebACLId(String),
MissingBody(String),
NoSuchFieldLevelEncryptionConfig(String),
NoSuchOrigin(String),
TooManyCacheBehaviors(String),
TooManyCertificates(String),
TooManyCookieNamesInWhiteList(String),
TooManyDistributionCNAMEs(String),
TooManyDistributions(String),
TooManyDistributionsAssociatedToFieldLevelEncryptionConfig(String),
TooManyDistributionsWithLambdaAssociations(String),
TooManyHeadersInForwardedValues(String),
TooManyLambdaFunctionAssociations(String),
TooManyOriginCustomHeaders(String),
TooManyOriginGroupsPerDistribution(String),
TooManyOrigins(String),
TooManyQueryStringParameters(String),
TooManyTrustedSigners(String),
TrustedSignerDoesNotExist(String),
}
impl CreateDistributionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateDistributionError> {
{
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[..] {
"AccessDenied" => return RusotoError::Service(CreateDistributionError::AccessDenied(parsed_error.message)),"CNAMEAlreadyExists" => return RusotoError::Service(CreateDistributionError::CNAMEAlreadyExists(parsed_error.message)),"DistributionAlreadyExists" => return RusotoError::Service(CreateDistributionError::DistributionAlreadyExists(parsed_error.message)),"IllegalFieldLevelEncryptionConfigAssociationWithCacheBehavior" => return RusotoError::Service(CreateDistributionError::IllegalFieldLevelEncryptionConfigAssociationWithCacheBehavior(parsed_error.message)),"InconsistentQuantities" => return RusotoError::Service(CreateDistributionError::InconsistentQuantities(parsed_error.message)),"InvalidArgument" => return RusotoError::Service(CreateDistributionError::InvalidArgument(parsed_error.message)),"InvalidDefaultRootObject" => return RusotoError::Service(CreateDistributionError::InvalidDefaultRootObject(parsed_error.message)),"InvalidErrorCode" => return RusotoError::Service(CreateDistributionError::InvalidErrorCode(parsed_error.message)),"InvalidForwardCookies" => return RusotoError::Service(CreateDistributionError::InvalidForwardCookies(parsed_error.message)),"InvalidGeoRestrictionParameter" => return RusotoError::Service(CreateDistributionError::InvalidGeoRestrictionParameter(parsed_error.message)),"InvalidHeadersForS3Origin" => return RusotoError::Service(CreateDistributionError::InvalidHeadersForS3Origin(parsed_error.message)),"InvalidLambdaFunctionAssociation" => return RusotoError::Service(CreateDistributionError::InvalidLambdaFunctionAssociation(parsed_error.message)),"InvalidLocationCode" => return RusotoError::Service(CreateDistributionError::InvalidLocationCode(parsed_error.message)),"InvalidMinimumProtocolVersion" => return RusotoError::Service(CreateDistributionError::InvalidMinimumProtocolVersion(parsed_error.message)),"InvalidOrigin" => return RusotoError::Service(CreateDistributionError::InvalidOrigin(parsed_error.message)),"InvalidOriginAccessIdentity" => return RusotoError::Service(CreateDistributionError::InvalidOriginAccessIdentity(parsed_error.message)),"InvalidOriginKeepaliveTimeout" => return RusotoError::Service(CreateDistributionError::InvalidOriginKeepaliveTimeout(parsed_error.message)),"InvalidOriginReadTimeout" => return RusotoError::Service(CreateDistributionError::InvalidOriginReadTimeout(parsed_error.message)),"InvalidProtocolSettings" => return RusotoError::Service(CreateDistributionError::InvalidProtocolSettings(parsed_error.message)),"InvalidQueryStringParameters" => return RusotoError::Service(CreateDistributionError::InvalidQueryStringParameters(parsed_error.message)),"InvalidRelativePath" => return RusotoError::Service(CreateDistributionError::InvalidRelativePath(parsed_error.message)),"InvalidRequiredProtocol" => return RusotoError::Service(CreateDistributionError::InvalidRequiredProtocol(parsed_error.message)),"InvalidResponseCode" => return RusotoError::Service(CreateDistributionError::InvalidResponseCode(parsed_error.message)),"InvalidTTLOrder" => return RusotoError::Service(CreateDistributionError::InvalidTTLOrder(parsed_error.message)),"InvalidViewerCertificate" => return RusotoError::Service(CreateDistributionError::InvalidViewerCertificate(parsed_error.message)),"InvalidWebACLId" => return RusotoError::Service(CreateDistributionError::InvalidWebACLId(parsed_error.message)),"MissingBody" => return RusotoError::Service(CreateDistributionError::MissingBody(parsed_error.message)),"NoSuchFieldLevelEncryptionConfig" => return RusotoError::Service(CreateDistributionError::NoSuchFieldLevelEncryptionConfig(parsed_error.message)),"NoSuchOrigin" => return RusotoError::Service(CreateDistributionError::NoSuchOrigin(parsed_error.message)),"TooManyCacheBehaviors" => return RusotoError::Service(CreateDistributionError::TooManyCacheBehaviors(parsed_error.message)),"TooManyCertificates" => return RusotoError::Service(CreateDistributionError::TooManyCertificates(parsed_error.message)),"TooManyCookieNamesInWhiteList" => return RusotoError::Service(CreateDistributionError::TooManyCookieNamesInWhiteList(parsed_error.message)),"TooManyDistributionCNAMEs" => return RusotoError::Service(CreateDistributionError::TooManyDistributionCNAMEs(parsed_error.message)),"TooManyDistributions" => return RusotoError::Service(CreateDistributionError::TooManyDistributions(parsed_error.message)),"TooManyDistributionsAssociatedToFieldLevelEncryptionConfig" => return RusotoError::Service(CreateDistributionError::TooManyDistributionsAssociatedToFieldLevelEncryptionConfig(parsed_error.message)),"TooManyDistributionsWithLambdaAssociations" => return RusotoError::Service(CreateDistributionError::TooManyDistributionsWithLambdaAssociations(parsed_error.message)),"TooManyHeadersInForwardedValues" => return RusotoError::Service(CreateDistributionError::TooManyHeadersInForwardedValues(parsed_error.message)),"TooManyLambdaFunctionAssociations" => return RusotoError::Service(CreateDistributionError::TooManyLambdaFunctionAssociations(parsed_error.message)),"TooManyOriginCustomHeaders" => return RusotoError::Service(CreateDistributionError::TooManyOriginCustomHeaders(parsed_error.message)),"TooManyOriginGroupsPerDistribution" => return RusotoError::Service(CreateDistributionError::TooManyOriginGroupsPerDistribution(parsed_error.message)),"TooManyOrigins" => return RusotoError::Service(CreateDistributionError::TooManyOrigins(parsed_error.message)),"TooManyQueryStringParameters" => return RusotoError::Service(CreateDistributionError::TooManyQueryStringParameters(parsed_error.message)),"TooManyTrustedSigners" => return RusotoError::Service(CreateDistributionError::TooManyTrustedSigners(parsed_error.message)),"TrustedSignerDoesNotExist" => return RusotoError::Service(CreateDistributionError::TrustedSignerDoesNotExist(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 CreateDistributionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateDistributionError::AccessDenied(ref cause) => write!(f, "{}", cause),
CreateDistributionError::CNAMEAlreadyExists(ref cause) => write!(f, "{}", cause),
CreateDistributionError::DistributionAlreadyExists(ref cause) => write!(f, "{}", cause),
CreateDistributionError::IllegalFieldLevelEncryptionConfigAssociationWithCacheBehavior(ref cause) => write!(f, "{}", cause),
CreateDistributionError::InconsistentQuantities(ref cause) => write!(f, "{}", cause),
CreateDistributionError::InvalidArgument(ref cause) => write!(f, "{}", cause),
CreateDistributionError::InvalidDefaultRootObject(ref cause) => write!(f, "{}", cause),
CreateDistributionError::InvalidErrorCode(ref cause) => write!(f, "{}", cause),
CreateDistributionError::InvalidForwardCookies(ref cause) => write!(f, "{}", cause),
CreateDistributionError::InvalidGeoRestrictionParameter(ref cause) => write!(f, "{}", cause),
CreateDistributionError::InvalidHeadersForS3Origin(ref cause) => write!(f, "{}", cause),
CreateDistributionError::InvalidLambdaFunctionAssociation(ref cause) => write!(f, "{}", cause),
CreateDistributionError::InvalidLocationCode(ref cause) => write!(f, "{}", cause),
CreateDistributionError::InvalidMinimumProtocolVersion(ref cause) => write!(f, "{}", cause),
CreateDistributionError::InvalidOrigin(ref cause) => write!(f, "{}", cause),
CreateDistributionError::InvalidOriginAccessIdentity(ref cause) => write!(f, "{}", cause),
CreateDistributionError::InvalidOriginKeepaliveTimeout(ref cause) => write!(f, "{}", cause),
CreateDistributionError::InvalidOriginReadTimeout(ref cause) => write!(f, "{}", cause),
CreateDistributionError::InvalidProtocolSettings(ref cause) => write!(f, "{}", cause),
CreateDistributionError::InvalidQueryStringParameters(ref cause) => write!(f, "{}", cause),
CreateDistributionError::InvalidRelativePath(ref cause) => write!(f, "{}", cause),
CreateDistributionError::InvalidRequiredProtocol(ref cause) => write!(f, "{}", cause),
CreateDistributionError::InvalidResponseCode(ref cause) => write!(f, "{}", cause),
CreateDistributionError::InvalidTTLOrder(ref cause) => write!(f, "{}", cause),
CreateDistributionError::InvalidViewerCertificate(ref cause) => write!(f, "{}", cause),
CreateDistributionError::InvalidWebACLId(ref cause) => write!(f, "{}", cause),
CreateDistributionError::MissingBody(ref cause) => write!(f, "{}", cause),
CreateDistributionError::NoSuchFieldLevelEncryptionConfig(ref cause) => write!(f, "{}", cause),
CreateDistributionError::NoSuchOrigin(ref cause) => write!(f, "{}", cause),
CreateDistributionError::TooManyCacheBehaviors(ref cause) => write!(f, "{}", cause),
CreateDistributionError::TooManyCertificates(ref cause) => write!(f, "{}", cause),
CreateDistributionError::TooManyCookieNamesInWhiteList(ref cause) => write!(f, "{}", cause),
CreateDistributionError::TooManyDistributionCNAMEs(ref cause) => write!(f, "{}", cause),
CreateDistributionError::TooManyDistributions(ref cause) => write!(f, "{}", cause),
CreateDistributionError::TooManyDistributionsAssociatedToFieldLevelEncryptionConfig(ref cause) => write!(f, "{}", cause),
CreateDistributionError::TooManyDistributionsWithLambdaAssociations(ref cause) => write!(f, "{}", cause),
CreateDistributionError::TooManyHeadersInForwardedValues(ref cause) => write!(f, "{}", cause),
CreateDistributionError::TooManyLambdaFunctionAssociations(ref cause) => write!(f, "{}", cause),
CreateDistributionError::TooManyOriginCustomHeaders(ref cause) => write!(f, "{}", cause),
CreateDistributionError::TooManyOriginGroupsPerDistribution(ref cause) => write!(f, "{}", cause),
CreateDistributionError::TooManyOrigins(ref cause) => write!(f, "{}", cause),
CreateDistributionError::TooManyQueryStringParameters(ref cause) => write!(f, "{}", cause),
CreateDistributionError::TooManyTrustedSigners(ref cause) => write!(f, "{}", cause),
CreateDistributionError::TrustedSignerDoesNotExist(ref cause) => write!(f, "{}", cause)
}
}
}
impl Error for CreateDistributionError {}
#[derive(Debug, PartialEq)]
pub enum CreateDistributionWithTagsError {
AccessDenied(String),
CNAMEAlreadyExists(String),
DistributionAlreadyExists(String),
IllegalFieldLevelEncryptionConfigAssociationWithCacheBehavior(String),
InconsistentQuantities(String),
InvalidArgument(String),
InvalidDefaultRootObject(String),
InvalidErrorCode(String),
InvalidForwardCookies(String),
InvalidGeoRestrictionParameter(String),
InvalidHeadersForS3Origin(String),
InvalidLambdaFunctionAssociation(String),
InvalidLocationCode(String),
InvalidMinimumProtocolVersion(String),
InvalidOrigin(String),
InvalidOriginAccessIdentity(String),
InvalidOriginKeepaliveTimeout(String),
InvalidOriginReadTimeout(String),
InvalidProtocolSettings(String),
InvalidQueryStringParameters(String),
InvalidRelativePath(String),
InvalidRequiredProtocol(String),
InvalidResponseCode(String),
InvalidTTLOrder(String),
InvalidTagging(String),
InvalidViewerCertificate(String),
InvalidWebACLId(String),
MissingBody(String),
NoSuchFieldLevelEncryptionConfig(String),
NoSuchOrigin(String),
TooManyCacheBehaviors(String),
TooManyCertificates(String),
TooManyCookieNamesInWhiteList(String),
TooManyDistributionCNAMEs(String),
TooManyDistributions(String),
TooManyDistributionsAssociatedToFieldLevelEncryptionConfig(String),
TooManyDistributionsWithLambdaAssociations(String),
TooManyHeadersInForwardedValues(String),
TooManyLambdaFunctionAssociations(String),
TooManyOriginCustomHeaders(String),
TooManyOriginGroupsPerDistribution(String),
TooManyOrigins(String),
TooManyQueryStringParameters(String),
TooManyTrustedSigners(String),
TrustedSignerDoesNotExist(String),
}
impl CreateDistributionWithTagsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<CreateDistributionWithTagsError> {
{
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[..] {
"AccessDenied" => return RusotoError::Service(CreateDistributionWithTagsError::AccessDenied(parsed_error.message)),"CNAMEAlreadyExists" => return RusotoError::Service(CreateDistributionWithTagsError::CNAMEAlreadyExists(parsed_error.message)),"DistributionAlreadyExists" => return RusotoError::Service(CreateDistributionWithTagsError::DistributionAlreadyExists(parsed_error.message)),"IllegalFieldLevelEncryptionConfigAssociationWithCacheBehavior" => return RusotoError::Service(CreateDistributionWithTagsError::IllegalFieldLevelEncryptionConfigAssociationWithCacheBehavior(parsed_error.message)),"InconsistentQuantities" => return RusotoError::Service(CreateDistributionWithTagsError::InconsistentQuantities(parsed_error.message)),"InvalidArgument" => return RusotoError::Service(CreateDistributionWithTagsError::InvalidArgument(parsed_error.message)),"InvalidDefaultRootObject" => return RusotoError::Service(CreateDistributionWithTagsError::InvalidDefaultRootObject(parsed_error.message)),"InvalidErrorCode" => return RusotoError::Service(CreateDistributionWithTagsError::InvalidErrorCode(parsed_error.message)),"InvalidForwardCookies" => return RusotoError::Service(CreateDistributionWithTagsError::InvalidForwardCookies(parsed_error.message)),"InvalidGeoRestrictionParameter" => return RusotoError::Service(CreateDistributionWithTagsError::InvalidGeoRestrictionParameter(parsed_error.message)),"InvalidHeadersForS3Origin" => return RusotoError::Service(CreateDistributionWithTagsError::InvalidHeadersForS3Origin(parsed_error.message)),"InvalidLambdaFunctionAssociation" => return RusotoError::Service(CreateDistributionWithTagsError::InvalidLambdaFunctionAssociation(parsed_error.message)),"InvalidLocationCode" => return RusotoError::Service(CreateDistributionWithTagsError::InvalidLocationCode(parsed_error.message)),"InvalidMinimumProtocolVersion" => return RusotoError::Service(CreateDistributionWithTagsError::InvalidMinimumProtocolVersion(parsed_error.message)),"InvalidOrigin" => return RusotoError::Service(CreateDistributionWithTagsError::InvalidOrigin(parsed_error.message)),"InvalidOriginAccessIdentity" => return RusotoError::Service(CreateDistributionWithTagsError::InvalidOriginAccessIdentity(parsed_error.message)),"InvalidOriginKeepaliveTimeout" => return RusotoError::Service(CreateDistributionWithTagsError::InvalidOriginKeepaliveTimeout(parsed_error.message)),"InvalidOriginReadTimeout" => return RusotoError::Service(CreateDistributionWithTagsError::InvalidOriginReadTimeout(parsed_error.message)),"InvalidProtocolSettings" => return RusotoError::Service(CreateDistributionWithTagsError::InvalidProtocolSettings(parsed_error.message)),"InvalidQueryStringParameters" => return RusotoError::Service(CreateDistributionWithTagsError::InvalidQueryStringParameters(parsed_error.message)),"InvalidRelativePath" => return RusotoError::Service(CreateDistributionWithTagsError::InvalidRelativePath(parsed_error.message)),"InvalidRequiredProtocol" => return RusotoError::Service(CreateDistributionWithTagsError::InvalidRequiredProtocol(parsed_error.message)),"InvalidResponseCode" => return RusotoError::Service(CreateDistributionWithTagsError::InvalidResponseCode(parsed_error.message)),"InvalidTTLOrder" => return RusotoError::Service(CreateDistributionWithTagsError::InvalidTTLOrder(parsed_error.message)),"InvalidTagging" => return RusotoError::Service(CreateDistributionWithTagsError::InvalidTagging(parsed_error.message)),"InvalidViewerCertificate" => return RusotoError::Service(CreateDistributionWithTagsError::InvalidViewerCertificate(parsed_error.message)),"InvalidWebACLId" => return RusotoError::Service(CreateDistributionWithTagsError::InvalidWebACLId(parsed_error.message)),"MissingBody" => return RusotoError::Service(CreateDistributionWithTagsError::MissingBody(parsed_error.message)),"NoSuchFieldLevelEncryptionConfig" => return RusotoError::Service(CreateDistributionWithTagsError::NoSuchFieldLevelEncryptionConfig(parsed_error.message)),"NoSuchOrigin" => return RusotoError::Service(CreateDistributionWithTagsError::NoSuchOrigin(parsed_error.message)),"TooManyCacheBehaviors" => return RusotoError::Service(CreateDistributionWithTagsError::TooManyCacheBehaviors(parsed_error.message)),"TooManyCertificates" => return RusotoError::Service(CreateDistributionWithTagsError::TooManyCertificates(parsed_error.message)),"TooManyCookieNamesInWhiteList" => return RusotoError::Service(CreateDistributionWithTagsError::TooManyCookieNamesInWhiteList(parsed_error.message)),"TooManyDistributionCNAMEs" => return RusotoError::Service(CreateDistributionWithTagsError::TooManyDistributionCNAMEs(parsed_error.message)),"TooManyDistributions" => return RusotoError::Service(CreateDistributionWithTagsError::TooManyDistributions(parsed_error.message)),"TooManyDistributionsAssociatedToFieldLevelEncryptionConfig" => return RusotoError::Service(CreateDistributionWithTagsError::TooManyDistributionsAssociatedToFieldLevelEncryptionConfig(parsed_error.message)),"TooManyDistributionsWithLambdaAssociations" => return RusotoError::Service(CreateDistributionWithTagsError::TooManyDistributionsWithLambdaAssociations(parsed_error.message)),"TooManyHeadersInForwardedValues" => return RusotoError::Service(CreateDistributionWithTagsError::TooManyHeadersInForwardedValues(parsed_error.message)),"TooManyLambdaFunctionAssociations" => return RusotoError::Service(CreateDistributionWithTagsError::TooManyLambdaFunctionAssociations(parsed_error.message)),"TooManyOriginCustomHeaders" => return RusotoError::Service(CreateDistributionWithTagsError::TooManyOriginCustomHeaders(parsed_error.message)),"TooManyOriginGroupsPerDistribution" => return RusotoError::Service(CreateDistributionWithTagsError::TooManyOriginGroupsPerDistribution(parsed_error.message)),"TooManyOrigins" => return RusotoError::Service(CreateDistributionWithTagsError::TooManyOrigins(parsed_error.message)),"TooManyQueryStringParameters" => return RusotoError::Service(CreateDistributionWithTagsError::TooManyQueryStringParameters(parsed_error.message)),"TooManyTrustedSigners" => return RusotoError::Service(CreateDistributionWithTagsError::TooManyTrustedSigners(parsed_error.message)),"TrustedSignerDoesNotExist" => return RusotoError::Service(CreateDistributionWithTagsError::TrustedSignerDoesNotExist(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 CreateDistributionWithTagsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateDistributionWithTagsError::AccessDenied(ref cause) => write!(f, "{}", cause),
CreateDistributionWithTagsError::CNAMEAlreadyExists(ref cause) => write!(f, "{}", cause),
CreateDistributionWithTagsError::DistributionAlreadyExists(ref cause) => write!(f, "{}", cause),
CreateDistributionWithTagsError::IllegalFieldLevelEncryptionConfigAssociationWithCacheBehavior(ref cause) => write!(f, "{}", cause),
CreateDistributionWithTagsError::InconsistentQuantities(ref cause) => write!(f, "{}", cause),
CreateDistributionWithTagsError::InvalidArgument(ref cause) => write!(f, "{}", cause),
CreateDistributionWithTagsError::InvalidDefaultRootObject(ref cause) => write!(f, "{}", cause),
CreateDistributionWithTagsError::InvalidErrorCode(ref cause) => write!(f, "{}", cause),
CreateDistributionWithTagsError::InvalidForwardCookies(ref cause) => write!(f, "{}", cause),
CreateDistributionWithTagsError::InvalidGeoRestrictionParameter(ref cause) => write!(f, "{}", cause),
CreateDistributionWithTagsError::InvalidHeadersForS3Origin(ref cause) => write!(f, "{}", cause),
CreateDistributionWithTagsError::InvalidLambdaFunctionAssociation(ref cause) => write!(f, "{}", cause),
CreateDistributionWithTagsError::InvalidLocationCode(ref cause) => write!(f, "{}", cause),
CreateDistributionWithTagsError::InvalidMinimumProtocolVersion(ref cause) => write!(f, "{}", cause),
CreateDistributionWithTagsError::InvalidOrigin(ref cause) => write!(f, "{}", cause),
CreateDistributionWithTagsError::InvalidOriginAccessIdentity(ref cause) => write!(f, "{}", cause),
CreateDistributionWithTagsError::InvalidOriginKeepaliveTimeout(ref cause) => write!(f, "{}", cause),
CreateDistributionWithTagsError::InvalidOriginReadTimeout(ref cause) => write!(f, "{}", cause),
CreateDistributionWithTagsError::InvalidProtocolSettings(ref cause) => write!(f, "{}", cause),
CreateDistributionWithTagsError::InvalidQueryStringParameters(ref cause) => write!(f, "{}", cause),
CreateDistributionWithTagsError::InvalidRelativePath(ref cause) => write!(f, "{}", cause),
CreateDistributionWithTagsError::InvalidRequiredProtocol(ref cause) => write!(f, "{}", cause),
CreateDistributionWithTagsError::InvalidResponseCode(ref cause) => write!(f, "{}", cause),
CreateDistributionWithTagsError::InvalidTTLOrder(ref cause) => write!(f, "{}", cause),
CreateDistributionWithTagsError::InvalidTagging(ref cause) => write!(f, "{}", cause),
CreateDistributionWithTagsError::InvalidViewerCertificate(ref cause) => write!(f, "{}", cause),
CreateDistributionWithTagsError::InvalidWebACLId(ref cause) => write!(f, "{}", cause),
CreateDistributionWithTagsError::MissingBody(ref cause) => write!(f, "{}", cause),
CreateDistributionWithTagsError::NoSuchFieldLevelEncryptionConfig(ref cause) => write!(f, "{}", cause),
CreateDistributionWithTagsError::NoSuchOrigin(ref cause) => write!(f, "{}", cause),
CreateDistributionWithTagsError::TooManyCacheBehaviors(ref cause) => write!(f, "{}", cause),
CreateDistributionWithTagsError::TooManyCertificates(ref cause) => write!(f, "{}", cause),
CreateDistributionWithTagsError::TooManyCookieNamesInWhiteList(ref cause) => write!(f, "{}", cause),
CreateDistributionWithTagsError::TooManyDistributionCNAMEs(ref cause) => write!(f, "{}", cause),
CreateDistributionWithTagsError::TooManyDistributions(ref cause) => write!(f, "{}", cause),
CreateDistributionWithTagsError::TooManyDistributionsAssociatedToFieldLevelEncryptionConfig(ref cause) => write!(f, "{}", cause),
CreateDistributionWithTagsError::TooManyDistributionsWithLambdaAssociations(ref cause) => write!(f, "{}", cause),
CreateDistributionWithTagsError::TooManyHeadersInForwardedValues(ref cause) => write!(f, "{}", cause),
CreateDistributionWithTagsError::TooManyLambdaFunctionAssociations(ref cause) => write!(f, "{}", cause),
CreateDistributionWithTagsError::TooManyOriginCustomHeaders(ref cause) => write!(f, "{}", cause),
CreateDistributionWithTagsError::TooManyOriginGroupsPerDistribution(ref cause) => write!(f, "{}", cause),
CreateDistributionWithTagsError::TooManyOrigins(ref cause) => write!(f, "{}", cause),
CreateDistributionWithTagsError::TooManyQueryStringParameters(ref cause) => write!(f, "{}", cause),
CreateDistributionWithTagsError::TooManyTrustedSigners(ref cause) => write!(f, "{}", cause),
CreateDistributionWithTagsError::TrustedSignerDoesNotExist(ref cause) => write!(f, "{}", cause)
}
}
}
impl Error for CreateDistributionWithTagsError {}
#[derive(Debug, PartialEq)]
pub enum CreateFieldLevelEncryptionConfigError {
FieldLevelEncryptionConfigAlreadyExists(String),
InconsistentQuantities(String),
InvalidArgument(String),
NoSuchFieldLevelEncryptionProfile(String),
QueryArgProfileEmpty(String),
TooManyFieldLevelEncryptionConfigs(String),
TooManyFieldLevelEncryptionContentTypeProfiles(String),
TooManyFieldLevelEncryptionQueryArgProfiles(String),
}
impl CreateFieldLevelEncryptionConfigError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<CreateFieldLevelEncryptionConfigError> {
{
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[..] {
"FieldLevelEncryptionConfigAlreadyExists" => return RusotoError::Service(CreateFieldLevelEncryptionConfigError::FieldLevelEncryptionConfigAlreadyExists(parsed_error.message)),"InconsistentQuantities" => return RusotoError::Service(CreateFieldLevelEncryptionConfigError::InconsistentQuantities(parsed_error.message)),"InvalidArgument" => return RusotoError::Service(CreateFieldLevelEncryptionConfigError::InvalidArgument(parsed_error.message)),"NoSuchFieldLevelEncryptionProfile" => return RusotoError::Service(CreateFieldLevelEncryptionConfigError::NoSuchFieldLevelEncryptionProfile(parsed_error.message)),"QueryArgProfileEmpty" => return RusotoError::Service(CreateFieldLevelEncryptionConfigError::QueryArgProfileEmpty(parsed_error.message)),"TooManyFieldLevelEncryptionConfigs" => return RusotoError::Service(CreateFieldLevelEncryptionConfigError::TooManyFieldLevelEncryptionConfigs(parsed_error.message)),"TooManyFieldLevelEncryptionContentTypeProfiles" => return RusotoError::Service(CreateFieldLevelEncryptionConfigError::TooManyFieldLevelEncryptionContentTypeProfiles(parsed_error.message)),"TooManyFieldLevelEncryptionQueryArgProfiles" => return RusotoError::Service(CreateFieldLevelEncryptionConfigError::TooManyFieldLevelEncryptionQueryArgProfiles(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 CreateFieldLevelEncryptionConfigError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateFieldLevelEncryptionConfigError::FieldLevelEncryptionConfigAlreadyExists(ref cause) => write!(f, "{}", cause),
CreateFieldLevelEncryptionConfigError::InconsistentQuantities(ref cause) => write!(f, "{}", cause),
CreateFieldLevelEncryptionConfigError::InvalidArgument(ref cause) => write!(f, "{}", cause),
CreateFieldLevelEncryptionConfigError::NoSuchFieldLevelEncryptionProfile(ref cause) => write!(f, "{}", cause),
CreateFieldLevelEncryptionConfigError::QueryArgProfileEmpty(ref cause) => write!(f, "{}", cause),
CreateFieldLevelEncryptionConfigError::TooManyFieldLevelEncryptionConfigs(ref cause) => write!(f, "{}", cause),
CreateFieldLevelEncryptionConfigError::TooManyFieldLevelEncryptionContentTypeProfiles(ref cause) => write!(f, "{}", cause),
CreateFieldLevelEncryptionConfigError::TooManyFieldLevelEncryptionQueryArgProfiles(ref cause) => write!(f, "{}", cause)
}
}
}
impl Error for CreateFieldLevelEncryptionConfigError {}
#[derive(Debug, PartialEq)]
pub enum CreateFieldLevelEncryptionProfileError {
FieldLevelEncryptionProfileAlreadyExists(String),
FieldLevelEncryptionProfileSizeExceeded(String),
InconsistentQuantities(String),
InvalidArgument(String),
NoSuchPublicKey(String),
TooManyFieldLevelEncryptionEncryptionEntities(String),
TooManyFieldLevelEncryptionFieldPatterns(String),
TooManyFieldLevelEncryptionProfiles(String),
}
impl CreateFieldLevelEncryptionProfileError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<CreateFieldLevelEncryptionProfileError> {
{
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[..] {
"FieldLevelEncryptionProfileAlreadyExists" => return RusotoError::Service(CreateFieldLevelEncryptionProfileError::FieldLevelEncryptionProfileAlreadyExists(parsed_error.message)),"FieldLevelEncryptionProfileSizeExceeded" => return RusotoError::Service(CreateFieldLevelEncryptionProfileError::FieldLevelEncryptionProfileSizeExceeded(parsed_error.message)),"InconsistentQuantities" => return RusotoError::Service(CreateFieldLevelEncryptionProfileError::InconsistentQuantities(parsed_error.message)),"InvalidArgument" => return RusotoError::Service(CreateFieldLevelEncryptionProfileError::InvalidArgument(parsed_error.message)),"NoSuchPublicKey" => return RusotoError::Service(CreateFieldLevelEncryptionProfileError::NoSuchPublicKey(parsed_error.message)),"TooManyFieldLevelEncryptionEncryptionEntities" => return RusotoError::Service(CreateFieldLevelEncryptionProfileError::TooManyFieldLevelEncryptionEncryptionEntities(parsed_error.message)),"TooManyFieldLevelEncryptionFieldPatterns" => return RusotoError::Service(CreateFieldLevelEncryptionProfileError::TooManyFieldLevelEncryptionFieldPatterns(parsed_error.message)),"TooManyFieldLevelEncryptionProfiles" => return RusotoError::Service(CreateFieldLevelEncryptionProfileError::TooManyFieldLevelEncryptionProfiles(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 CreateFieldLevelEncryptionProfileError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateFieldLevelEncryptionProfileError::FieldLevelEncryptionProfileAlreadyExists(ref cause) => write!(f, "{}", cause),
CreateFieldLevelEncryptionProfileError::FieldLevelEncryptionProfileSizeExceeded(ref cause) => write!(f, "{}", cause),
CreateFieldLevelEncryptionProfileError::InconsistentQuantities(ref cause) => write!(f, "{}", cause),
CreateFieldLevelEncryptionProfileError::InvalidArgument(ref cause) => write!(f, "{}", cause),
CreateFieldLevelEncryptionProfileError::NoSuchPublicKey(ref cause) => write!(f, "{}", cause),
CreateFieldLevelEncryptionProfileError::TooManyFieldLevelEncryptionEncryptionEntities(ref cause) => write!(f, "{}", cause),
CreateFieldLevelEncryptionProfileError::TooManyFieldLevelEncryptionFieldPatterns(ref cause) => write!(f, "{}", cause),
CreateFieldLevelEncryptionProfileError::TooManyFieldLevelEncryptionProfiles(ref cause) => write!(f, "{}", cause)
}
}
}
impl Error for CreateFieldLevelEncryptionProfileError {}
#[derive(Debug, PartialEq)]
pub enum CreateInvalidationError {
AccessDenied(String),
BatchTooLarge(String),
InconsistentQuantities(String),
InvalidArgument(String),
MissingBody(String),
NoSuchDistribution(String),
TooManyInvalidationsInProgress(String),
}
impl CreateInvalidationError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateInvalidationError> {
{
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[..] {
"AccessDenied" => {
return RusotoError::Service(CreateInvalidationError::AccessDenied(
parsed_error.message,
))
}
"BatchTooLarge" => {
return RusotoError::Service(CreateInvalidationError::BatchTooLarge(
parsed_error.message,
))
}
"InconsistentQuantities" => {
return RusotoError::Service(
CreateInvalidationError::InconsistentQuantities(parsed_error.message),
)
}
"InvalidArgument" => {
return RusotoError::Service(CreateInvalidationError::InvalidArgument(
parsed_error.message,
))
}
"MissingBody" => {
return RusotoError::Service(CreateInvalidationError::MissingBody(
parsed_error.message,
))
}
"NoSuchDistribution" => {
return RusotoError::Service(CreateInvalidationError::NoSuchDistribution(
parsed_error.message,
))
}
"TooManyInvalidationsInProgress" => {
return RusotoError::Service(
CreateInvalidationError::TooManyInvalidationsInProgress(
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 CreateInvalidationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateInvalidationError::AccessDenied(ref cause) => write!(f, "{}", cause),
CreateInvalidationError::BatchTooLarge(ref cause) => write!(f, "{}", cause),
CreateInvalidationError::InconsistentQuantities(ref cause) => write!(f, "{}", cause),
CreateInvalidationError::InvalidArgument(ref cause) => write!(f, "{}", cause),
CreateInvalidationError::MissingBody(ref cause) => write!(f, "{}", cause),
CreateInvalidationError::NoSuchDistribution(ref cause) => write!(f, "{}", cause),
CreateInvalidationError::TooManyInvalidationsInProgress(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for CreateInvalidationError {}
#[derive(Debug, PartialEq)]
pub enum CreatePublicKeyError {
InvalidArgument(String),
PublicKeyAlreadyExists(String),
TooManyPublicKeys(String),
}
impl CreatePublicKeyError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreatePublicKeyError> {
{
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[..] {
"InvalidArgument" => {
return RusotoError::Service(CreatePublicKeyError::InvalidArgument(
parsed_error.message,
))
}
"PublicKeyAlreadyExists" => {
return RusotoError::Service(CreatePublicKeyError::PublicKeyAlreadyExists(
parsed_error.message,
))
}
"TooManyPublicKeys" => {
return RusotoError::Service(CreatePublicKeyError::TooManyPublicKeys(
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 CreatePublicKeyError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreatePublicKeyError::InvalidArgument(ref cause) => write!(f, "{}", cause),
CreatePublicKeyError::PublicKeyAlreadyExists(ref cause) => write!(f, "{}", cause),
CreatePublicKeyError::TooManyPublicKeys(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreatePublicKeyError {}
#[derive(Debug, PartialEq)]
pub enum CreateStreamingDistributionError {
AccessDenied(String),
CNAMEAlreadyExists(String),
InconsistentQuantities(String),
InvalidArgument(String),
InvalidOrigin(String),
InvalidOriginAccessIdentity(String),
MissingBody(String),
StreamingDistributionAlreadyExists(String),
TooManyStreamingDistributionCNAMEs(String),
TooManyStreamingDistributions(String),
TooManyTrustedSigners(String),
TrustedSignerDoesNotExist(String),
}
impl CreateStreamingDistributionError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<CreateStreamingDistributionError> {
{
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[..] {
"AccessDenied" => {
return RusotoError::Service(
CreateStreamingDistributionError::AccessDenied(parsed_error.message),
)
}
"CNAMEAlreadyExists" => {
return RusotoError::Service(
CreateStreamingDistributionError::CNAMEAlreadyExists(
parsed_error.message,
),
)
}
"InconsistentQuantities" => {
return RusotoError::Service(
CreateStreamingDistributionError::InconsistentQuantities(
parsed_error.message,
),
)
}
"InvalidArgument" => {
return RusotoError::Service(
CreateStreamingDistributionError::InvalidArgument(parsed_error.message),
)
}
"InvalidOrigin" => {
return RusotoError::Service(
CreateStreamingDistributionError::InvalidOrigin(parsed_error.message),
)
}
"InvalidOriginAccessIdentity" => {
return RusotoError::Service(
CreateStreamingDistributionError::InvalidOriginAccessIdentity(
parsed_error.message,
),
)
}
"MissingBody" => {
return RusotoError::Service(CreateStreamingDistributionError::MissingBody(
parsed_error.message,
))
}
"StreamingDistributionAlreadyExists" => {
return RusotoError::Service(
CreateStreamingDistributionError::StreamingDistributionAlreadyExists(
parsed_error.message,
),
)
}
"TooManyStreamingDistributionCNAMEs" => {
return RusotoError::Service(
CreateStreamingDistributionError::TooManyStreamingDistributionCNAMEs(
parsed_error.message,
),
)
}
"TooManyStreamingDistributions" => {
return RusotoError::Service(
CreateStreamingDistributionError::TooManyStreamingDistributions(
parsed_error.message,
),
)
}
"TooManyTrustedSigners" => {
return RusotoError::Service(
CreateStreamingDistributionError::TooManyTrustedSigners(
parsed_error.message,
),
)
}
"TrustedSignerDoesNotExist" => {
return RusotoError::Service(
CreateStreamingDistributionError::TrustedSignerDoesNotExist(
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 CreateStreamingDistributionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateStreamingDistributionError::AccessDenied(ref cause) => write!(f, "{}", cause),
CreateStreamingDistributionError::CNAMEAlreadyExists(ref cause) => {
write!(f, "{}", cause)
}
CreateStreamingDistributionError::InconsistentQuantities(ref cause) => {
write!(f, "{}", cause)
}
CreateStreamingDistributionError::InvalidArgument(ref cause) => write!(f, "{}", cause),
CreateStreamingDistributionError::InvalidOrigin(ref cause) => write!(f, "{}", cause),
CreateStreamingDistributionError::InvalidOriginAccessIdentity(ref cause) => {
write!(f, "{}", cause)
}
CreateStreamingDistributionError::MissingBody(ref cause) => write!(f, "{}", cause),
CreateStreamingDistributionError::StreamingDistributionAlreadyExists(ref cause) => {
write!(f, "{}", cause)
}
CreateStreamingDistributionError::TooManyStreamingDistributionCNAMEs(ref cause) => {
write!(f, "{}", cause)
}
CreateStreamingDistributionError::TooManyStreamingDistributions(ref cause) => {
write!(f, "{}", cause)
}
CreateStreamingDistributionError::TooManyTrustedSigners(ref cause) => {
write!(f, "{}", cause)
}
CreateStreamingDistributionError::TrustedSignerDoesNotExist(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for CreateStreamingDistributionError {}
#[derive(Debug, PartialEq)]
pub enum CreateStreamingDistributionWithTagsError {
AccessDenied(String),
CNAMEAlreadyExists(String),
InconsistentQuantities(String),
InvalidArgument(String),
InvalidOrigin(String),
InvalidOriginAccessIdentity(String),
InvalidTagging(String),
MissingBody(String),
StreamingDistributionAlreadyExists(String),
TooManyStreamingDistributionCNAMEs(String),
TooManyStreamingDistributions(String),
TooManyTrustedSigners(String),
TrustedSignerDoesNotExist(String),
}
impl CreateStreamingDistributionWithTagsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<CreateStreamingDistributionWithTagsError> {
{
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[..] {
"AccessDenied" => return RusotoError::Service(CreateStreamingDistributionWithTagsError::AccessDenied(parsed_error.message)),"CNAMEAlreadyExists" => return RusotoError::Service(CreateStreamingDistributionWithTagsError::CNAMEAlreadyExists(parsed_error.message)),"InconsistentQuantities" => return RusotoError::Service(CreateStreamingDistributionWithTagsError::InconsistentQuantities(parsed_error.message)),"InvalidArgument" => return RusotoError::Service(CreateStreamingDistributionWithTagsError::InvalidArgument(parsed_error.message)),"InvalidOrigin" => return RusotoError::Service(CreateStreamingDistributionWithTagsError::InvalidOrigin(parsed_error.message)),"InvalidOriginAccessIdentity" => return RusotoError::Service(CreateStreamingDistributionWithTagsError::InvalidOriginAccessIdentity(parsed_error.message)),"InvalidTagging" => return RusotoError::Service(CreateStreamingDistributionWithTagsError::InvalidTagging(parsed_error.message)),"MissingBody" => return RusotoError::Service(CreateStreamingDistributionWithTagsError::MissingBody(parsed_error.message)),"StreamingDistributionAlreadyExists" => return RusotoError::Service(CreateStreamingDistributionWithTagsError::StreamingDistributionAlreadyExists(parsed_error.message)),"TooManyStreamingDistributionCNAMEs" => return RusotoError::Service(CreateStreamingDistributionWithTagsError::TooManyStreamingDistributionCNAMEs(parsed_error.message)),"TooManyStreamingDistributions" => return RusotoError::Service(CreateStreamingDistributionWithTagsError::TooManyStreamingDistributions(parsed_error.message)),"TooManyTrustedSigners" => return RusotoError::Service(CreateStreamingDistributionWithTagsError::TooManyTrustedSigners(parsed_error.message)),"TrustedSignerDoesNotExist" => return RusotoError::Service(CreateStreamingDistributionWithTagsError::TrustedSignerDoesNotExist(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 CreateStreamingDistributionWithTagsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateStreamingDistributionWithTagsError::AccessDenied(ref cause) => {
write!(f, "{}", cause)
}
CreateStreamingDistributionWithTagsError::CNAMEAlreadyExists(ref cause) => {
write!(f, "{}", cause)
}
CreateStreamingDistributionWithTagsError::InconsistentQuantities(ref cause) => {
write!(f, "{}", cause)
}
CreateStreamingDistributionWithTagsError::InvalidArgument(ref cause) => {
write!(f, "{}", cause)
}
CreateStreamingDistributionWithTagsError::InvalidOrigin(ref cause) => {
write!(f, "{}", cause)
}
CreateStreamingDistributionWithTagsError::InvalidOriginAccessIdentity(ref cause) => {
write!(f, "{}", cause)
}
CreateStreamingDistributionWithTagsError::InvalidTagging(ref cause) => {
write!(f, "{}", cause)
}
CreateStreamingDistributionWithTagsError::MissingBody(ref cause) => {
write!(f, "{}", cause)
}
CreateStreamingDistributionWithTagsError::StreamingDistributionAlreadyExists(
ref cause,
) => write!(f, "{}", cause),
CreateStreamingDistributionWithTagsError::TooManyStreamingDistributionCNAMEs(
ref cause,
) => write!(f, "{}", cause),
CreateStreamingDistributionWithTagsError::TooManyStreamingDistributions(ref cause) => {
write!(f, "{}", cause)
}
CreateStreamingDistributionWithTagsError::TooManyTrustedSigners(ref cause) => {
write!(f, "{}", cause)
}
CreateStreamingDistributionWithTagsError::TrustedSignerDoesNotExist(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for CreateStreamingDistributionWithTagsError {}
#[derive(Debug, PartialEq)]
pub enum DeleteCloudFrontOriginAccessIdentityError {
AccessDenied(String),
CloudFrontOriginAccessIdentityInUse(String),
InvalidIfMatchVersion(String),
NoSuchCloudFrontOriginAccessIdentity(String),
PreconditionFailed(String),
}
impl DeleteCloudFrontOriginAccessIdentityError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DeleteCloudFrontOriginAccessIdentityError> {
{
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[..] {
"AccessDenied" => return RusotoError::Service(DeleteCloudFrontOriginAccessIdentityError::AccessDenied(parsed_error.message)),"CloudFrontOriginAccessIdentityInUse" => return RusotoError::Service(DeleteCloudFrontOriginAccessIdentityError::CloudFrontOriginAccessIdentityInUse(parsed_error.message)),"InvalidIfMatchVersion" => return RusotoError::Service(DeleteCloudFrontOriginAccessIdentityError::InvalidIfMatchVersion(parsed_error.message)),"NoSuchCloudFrontOriginAccessIdentity" => return RusotoError::Service(DeleteCloudFrontOriginAccessIdentityError::NoSuchCloudFrontOriginAccessIdentity(parsed_error.message)),"PreconditionFailed" => return RusotoError::Service(DeleteCloudFrontOriginAccessIdentityError::PreconditionFailed(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 DeleteCloudFrontOriginAccessIdentityError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteCloudFrontOriginAccessIdentityError::AccessDenied(ref cause) => {
write!(f, "{}", cause)
}
DeleteCloudFrontOriginAccessIdentityError::CloudFrontOriginAccessIdentityInUse(
ref cause,
) => write!(f, "{}", cause),
DeleteCloudFrontOriginAccessIdentityError::InvalidIfMatchVersion(ref cause) => {
write!(f, "{}", cause)
}
DeleteCloudFrontOriginAccessIdentityError::NoSuchCloudFrontOriginAccessIdentity(
ref cause,
) => write!(f, "{}", cause),
DeleteCloudFrontOriginAccessIdentityError::PreconditionFailed(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DeleteCloudFrontOriginAccessIdentityError {}
#[derive(Debug, PartialEq)]
pub enum DeleteDistributionError {
AccessDenied(String),
DistributionNotDisabled(String),
InvalidIfMatchVersion(String),
NoSuchDistribution(String),
PreconditionFailed(String),
}
impl DeleteDistributionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteDistributionError> {
{
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[..] {
"AccessDenied" => {
return RusotoError::Service(DeleteDistributionError::AccessDenied(
parsed_error.message,
))
}
"DistributionNotDisabled" => {
return RusotoError::Service(
DeleteDistributionError::DistributionNotDisabled(parsed_error.message),
)
}
"InvalidIfMatchVersion" => {
return RusotoError::Service(
DeleteDistributionError::InvalidIfMatchVersion(parsed_error.message),
)
}
"NoSuchDistribution" => {
return RusotoError::Service(DeleteDistributionError::NoSuchDistribution(
parsed_error.message,
))
}
"PreconditionFailed" => {
return RusotoError::Service(DeleteDistributionError::PreconditionFailed(
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 DeleteDistributionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteDistributionError::AccessDenied(ref cause) => write!(f, "{}", cause),
DeleteDistributionError::DistributionNotDisabled(ref cause) => write!(f, "{}", cause),
DeleteDistributionError::InvalidIfMatchVersion(ref cause) => write!(f, "{}", cause),
DeleteDistributionError::NoSuchDistribution(ref cause) => write!(f, "{}", cause),
DeleteDistributionError::PreconditionFailed(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteDistributionError {}
#[derive(Debug, PartialEq)]
pub enum DeleteFieldLevelEncryptionConfigError {
AccessDenied(String),
FieldLevelEncryptionConfigInUse(String),
InvalidIfMatchVersion(String),
NoSuchFieldLevelEncryptionConfig(String),
PreconditionFailed(String),
}
impl DeleteFieldLevelEncryptionConfigError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DeleteFieldLevelEncryptionConfigError> {
{
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[..] {
"AccessDenied" => {
return RusotoError::Service(
DeleteFieldLevelEncryptionConfigError::AccessDenied(
parsed_error.message,
),
)
}
"FieldLevelEncryptionConfigInUse" => {
return RusotoError::Service(
DeleteFieldLevelEncryptionConfigError::FieldLevelEncryptionConfigInUse(
parsed_error.message,
),
)
}
"InvalidIfMatchVersion" => {
return RusotoError::Service(
DeleteFieldLevelEncryptionConfigError::InvalidIfMatchVersion(
parsed_error.message,
),
)
}
"NoSuchFieldLevelEncryptionConfig" => {
return RusotoError::Service(
DeleteFieldLevelEncryptionConfigError::NoSuchFieldLevelEncryptionConfig(
parsed_error.message,
),
)
}
"PreconditionFailed" => {
return RusotoError::Service(
DeleteFieldLevelEncryptionConfigError::PreconditionFailed(
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 DeleteFieldLevelEncryptionConfigError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteFieldLevelEncryptionConfigError::AccessDenied(ref cause) => {
write!(f, "{}", cause)
}
DeleteFieldLevelEncryptionConfigError::FieldLevelEncryptionConfigInUse(ref cause) => {
write!(f, "{}", cause)
}
DeleteFieldLevelEncryptionConfigError::InvalidIfMatchVersion(ref cause) => {
write!(f, "{}", cause)
}
DeleteFieldLevelEncryptionConfigError::NoSuchFieldLevelEncryptionConfig(ref cause) => {
write!(f, "{}", cause)
}
DeleteFieldLevelEncryptionConfigError::PreconditionFailed(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DeleteFieldLevelEncryptionConfigError {}
#[derive(Debug, PartialEq)]
pub enum DeleteFieldLevelEncryptionProfileError {
AccessDenied(String),
FieldLevelEncryptionProfileInUse(String),
InvalidIfMatchVersion(String),
NoSuchFieldLevelEncryptionProfile(String),
PreconditionFailed(String),
}
impl DeleteFieldLevelEncryptionProfileError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DeleteFieldLevelEncryptionProfileError> {
{
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[..] {
"AccessDenied" => {
return RusotoError::Service(
DeleteFieldLevelEncryptionProfileError::AccessDenied(
parsed_error.message,
),
)
}
"FieldLevelEncryptionProfileInUse" => return RusotoError::Service(
DeleteFieldLevelEncryptionProfileError::FieldLevelEncryptionProfileInUse(
parsed_error.message,
),
),
"InvalidIfMatchVersion" => {
return RusotoError::Service(
DeleteFieldLevelEncryptionProfileError::InvalidIfMatchVersion(
parsed_error.message,
),
)
}
"NoSuchFieldLevelEncryptionProfile" => return RusotoError::Service(
DeleteFieldLevelEncryptionProfileError::NoSuchFieldLevelEncryptionProfile(
parsed_error.message,
),
),
"PreconditionFailed" => {
return RusotoError::Service(
DeleteFieldLevelEncryptionProfileError::PreconditionFailed(
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 DeleteFieldLevelEncryptionProfileError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteFieldLevelEncryptionProfileError::AccessDenied(ref cause) => {
write!(f, "{}", cause)
}
DeleteFieldLevelEncryptionProfileError::FieldLevelEncryptionProfileInUse(ref cause) => {
write!(f, "{}", cause)
}
DeleteFieldLevelEncryptionProfileError::InvalidIfMatchVersion(ref cause) => {
write!(f, "{}", cause)
}
DeleteFieldLevelEncryptionProfileError::NoSuchFieldLevelEncryptionProfile(
ref cause,
) => write!(f, "{}", cause),
DeleteFieldLevelEncryptionProfileError::PreconditionFailed(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DeleteFieldLevelEncryptionProfileError {}
#[derive(Debug, PartialEq)]
pub enum DeletePublicKeyError {
AccessDenied(String),
InvalidIfMatchVersion(String),
NoSuchPublicKey(String),
PreconditionFailed(String),
PublicKeyInUse(String),
}
impl DeletePublicKeyError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeletePublicKeyError> {
{
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[..] {
"AccessDenied" => {
return RusotoError::Service(DeletePublicKeyError::AccessDenied(
parsed_error.message,
))
}
"InvalidIfMatchVersion" => {
return RusotoError::Service(DeletePublicKeyError::InvalidIfMatchVersion(
parsed_error.message,
))
}
"NoSuchPublicKey" => {
return RusotoError::Service(DeletePublicKeyError::NoSuchPublicKey(
parsed_error.message,
))
}
"PreconditionFailed" => {
return RusotoError::Service(DeletePublicKeyError::PreconditionFailed(
parsed_error.message,
))
}
"PublicKeyInUse" => {
return RusotoError::Service(DeletePublicKeyError::PublicKeyInUse(
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 DeletePublicKeyError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeletePublicKeyError::AccessDenied(ref cause) => write!(f, "{}", cause),
DeletePublicKeyError::InvalidIfMatchVersion(ref cause) => write!(f, "{}", cause),
DeletePublicKeyError::NoSuchPublicKey(ref cause) => write!(f, "{}", cause),
DeletePublicKeyError::PreconditionFailed(ref cause) => write!(f, "{}", cause),
DeletePublicKeyError::PublicKeyInUse(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeletePublicKeyError {}
#[derive(Debug, PartialEq)]
pub enum DeleteStreamingDistributionError {
AccessDenied(String),
InvalidIfMatchVersion(String),
NoSuchStreamingDistribution(String),
PreconditionFailed(String),
StreamingDistributionNotDisabled(String),
}
impl DeleteStreamingDistributionError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DeleteStreamingDistributionError> {
{
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[..] {
"AccessDenied" => {
return RusotoError::Service(
DeleteStreamingDistributionError::AccessDenied(parsed_error.message),
)
}
"InvalidIfMatchVersion" => {
return RusotoError::Service(
DeleteStreamingDistributionError::InvalidIfMatchVersion(
parsed_error.message,
),
)
}
"NoSuchStreamingDistribution" => {
return RusotoError::Service(
DeleteStreamingDistributionError::NoSuchStreamingDistribution(
parsed_error.message,
),
)
}
"PreconditionFailed" => {
return RusotoError::Service(
DeleteStreamingDistributionError::PreconditionFailed(
parsed_error.message,
),
)
}
"StreamingDistributionNotDisabled" => {
return RusotoError::Service(
DeleteStreamingDistributionError::StreamingDistributionNotDisabled(
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 DeleteStreamingDistributionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteStreamingDistributionError::AccessDenied(ref cause) => write!(f, "{}", cause),
DeleteStreamingDistributionError::InvalidIfMatchVersion(ref cause) => {
write!(f, "{}", cause)
}
DeleteStreamingDistributionError::NoSuchStreamingDistribution(ref cause) => {
write!(f, "{}", cause)
}
DeleteStreamingDistributionError::PreconditionFailed(ref cause) => {
write!(f, "{}", cause)
}
DeleteStreamingDistributionError::StreamingDistributionNotDisabled(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DeleteStreamingDistributionError {}
#[derive(Debug, PartialEq)]
pub enum GetCloudFrontOriginAccessIdentityError {
AccessDenied(String),
NoSuchCloudFrontOriginAccessIdentity(String),
}
impl GetCloudFrontOriginAccessIdentityError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<GetCloudFrontOriginAccessIdentityError> {
{
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[..] {
"AccessDenied" => return RusotoError::Service(GetCloudFrontOriginAccessIdentityError::AccessDenied(parsed_error.message)),"NoSuchCloudFrontOriginAccessIdentity" => return RusotoError::Service(GetCloudFrontOriginAccessIdentityError::NoSuchCloudFrontOriginAccessIdentity(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 GetCloudFrontOriginAccessIdentityError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetCloudFrontOriginAccessIdentityError::AccessDenied(ref cause) => {
write!(f, "{}", cause)
}
GetCloudFrontOriginAccessIdentityError::NoSuchCloudFrontOriginAccessIdentity(
ref cause,
) => write!(f, "{}", cause),
}
}
}
impl Error for GetCloudFrontOriginAccessIdentityError {}
#[derive(Debug, PartialEq)]
pub enum GetCloudFrontOriginAccessIdentityConfigError {
AccessDenied(String),
NoSuchCloudFrontOriginAccessIdentity(String),
}
impl GetCloudFrontOriginAccessIdentityConfigError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<GetCloudFrontOriginAccessIdentityConfigError> {
{
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[..] {
"AccessDenied" => return RusotoError::Service(GetCloudFrontOriginAccessIdentityConfigError::AccessDenied(parsed_error.message)),"NoSuchCloudFrontOriginAccessIdentity" => return RusotoError::Service(GetCloudFrontOriginAccessIdentityConfigError::NoSuchCloudFrontOriginAccessIdentity(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 GetCloudFrontOriginAccessIdentityConfigError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetCloudFrontOriginAccessIdentityConfigError::AccessDenied(ref cause) => {
write!(f, "{}", cause)
}
GetCloudFrontOriginAccessIdentityConfigError::NoSuchCloudFrontOriginAccessIdentity(
ref cause,
) => write!(f, "{}", cause),
}
}
}
impl Error for GetCloudFrontOriginAccessIdentityConfigError {}
#[derive(Debug, PartialEq)]
pub enum GetDistributionError {
AccessDenied(String),
NoSuchDistribution(String),
}
impl GetDistributionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetDistributionError> {
{
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[..] {
"AccessDenied" => {
return RusotoError::Service(GetDistributionError::AccessDenied(
parsed_error.message,
))
}
"NoSuchDistribution" => {
return RusotoError::Service(GetDistributionError::NoSuchDistribution(
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 GetDistributionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetDistributionError::AccessDenied(ref cause) => write!(f, "{}", cause),
GetDistributionError::NoSuchDistribution(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetDistributionError {}
#[derive(Debug, PartialEq)]
pub enum GetDistributionConfigError {
AccessDenied(String),
NoSuchDistribution(String),
}
impl GetDistributionConfigError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetDistributionConfigError> {
{
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[..] {
"AccessDenied" => {
return RusotoError::Service(GetDistributionConfigError::AccessDenied(
parsed_error.message,
))
}
"NoSuchDistribution" => {
return RusotoError::Service(
GetDistributionConfigError::NoSuchDistribution(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 GetDistributionConfigError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetDistributionConfigError::AccessDenied(ref cause) => write!(f, "{}", cause),
GetDistributionConfigError::NoSuchDistribution(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetDistributionConfigError {}
#[derive(Debug, PartialEq)]
pub enum GetFieldLevelEncryptionError {
AccessDenied(String),
NoSuchFieldLevelEncryptionConfig(String),
}
impl GetFieldLevelEncryptionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetFieldLevelEncryptionError> {
{
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[..] {
"AccessDenied" => {
return RusotoError::Service(GetFieldLevelEncryptionError::AccessDenied(
parsed_error.message,
))
}
"NoSuchFieldLevelEncryptionConfig" => {
return RusotoError::Service(
GetFieldLevelEncryptionError::NoSuchFieldLevelEncryptionConfig(
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 GetFieldLevelEncryptionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetFieldLevelEncryptionError::AccessDenied(ref cause) => write!(f, "{}", cause),
GetFieldLevelEncryptionError::NoSuchFieldLevelEncryptionConfig(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for GetFieldLevelEncryptionError {}
#[derive(Debug, PartialEq)]
pub enum GetFieldLevelEncryptionConfigError {
AccessDenied(String),
NoSuchFieldLevelEncryptionConfig(String),
}
impl GetFieldLevelEncryptionConfigError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<GetFieldLevelEncryptionConfigError> {
{
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[..] {
"AccessDenied" => {
return RusotoError::Service(
GetFieldLevelEncryptionConfigError::AccessDenied(parsed_error.message),
)
}
"NoSuchFieldLevelEncryptionConfig" => {
return RusotoError::Service(
GetFieldLevelEncryptionConfigError::NoSuchFieldLevelEncryptionConfig(
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 GetFieldLevelEncryptionConfigError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetFieldLevelEncryptionConfigError::AccessDenied(ref cause) => write!(f, "{}", cause),
GetFieldLevelEncryptionConfigError::NoSuchFieldLevelEncryptionConfig(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for GetFieldLevelEncryptionConfigError {}
#[derive(Debug, PartialEq)]
pub enum GetFieldLevelEncryptionProfileError {
AccessDenied(String),
NoSuchFieldLevelEncryptionProfile(String),
}
impl GetFieldLevelEncryptionProfileError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<GetFieldLevelEncryptionProfileError> {
{
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[..] {
"AccessDenied" => {
return RusotoError::Service(
GetFieldLevelEncryptionProfileError::AccessDenied(parsed_error.message),
)
}
"NoSuchFieldLevelEncryptionProfile" => {
return RusotoError::Service(
GetFieldLevelEncryptionProfileError::NoSuchFieldLevelEncryptionProfile(
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 GetFieldLevelEncryptionProfileError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetFieldLevelEncryptionProfileError::AccessDenied(ref cause) => write!(f, "{}", cause),
GetFieldLevelEncryptionProfileError::NoSuchFieldLevelEncryptionProfile(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for GetFieldLevelEncryptionProfileError {}
#[derive(Debug, PartialEq)]
pub enum GetFieldLevelEncryptionProfileConfigError {
AccessDenied(String),
NoSuchFieldLevelEncryptionProfile(String),
}
impl GetFieldLevelEncryptionProfileConfigError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<GetFieldLevelEncryptionProfileConfigError> {
{
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[..] {
"AccessDenied" => return RusotoError::Service(GetFieldLevelEncryptionProfileConfigError::AccessDenied(parsed_error.message)),"NoSuchFieldLevelEncryptionProfile" => return RusotoError::Service(GetFieldLevelEncryptionProfileConfigError::NoSuchFieldLevelEncryptionProfile(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 GetFieldLevelEncryptionProfileConfigError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetFieldLevelEncryptionProfileConfigError::AccessDenied(ref cause) => {
write!(f, "{}", cause)
}
GetFieldLevelEncryptionProfileConfigError::NoSuchFieldLevelEncryptionProfile(
ref cause,
) => write!(f, "{}", cause),
}
}
}
impl Error for GetFieldLevelEncryptionProfileConfigError {}
#[derive(Debug, PartialEq)]
pub enum GetInvalidationError {
AccessDenied(String),
NoSuchDistribution(String),
NoSuchInvalidation(String),
}
impl GetInvalidationError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetInvalidationError> {
{
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[..] {
"AccessDenied" => {
return RusotoError::Service(GetInvalidationError::AccessDenied(
parsed_error.message,
))
}
"NoSuchDistribution" => {
return RusotoError::Service(GetInvalidationError::NoSuchDistribution(
parsed_error.message,
))
}
"NoSuchInvalidation" => {
return RusotoError::Service(GetInvalidationError::NoSuchInvalidation(
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 GetInvalidationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetInvalidationError::AccessDenied(ref cause) => write!(f, "{}", cause),
GetInvalidationError::NoSuchDistribution(ref cause) => write!(f, "{}", cause),
GetInvalidationError::NoSuchInvalidation(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetInvalidationError {}
#[derive(Debug, PartialEq)]
pub enum GetPublicKeyError {
AccessDenied(String),
NoSuchPublicKey(String),
}
impl GetPublicKeyError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetPublicKeyError> {
{
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[..] {
"AccessDenied" => {
return RusotoError::Service(GetPublicKeyError::AccessDenied(
parsed_error.message,
))
}
"NoSuchPublicKey" => {
return RusotoError::Service(GetPublicKeyError::NoSuchPublicKey(
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 GetPublicKeyError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetPublicKeyError::AccessDenied(ref cause) => write!(f, "{}", cause),
GetPublicKeyError::NoSuchPublicKey(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetPublicKeyError {}
#[derive(Debug, PartialEq)]
pub enum GetPublicKeyConfigError {
AccessDenied(String),
NoSuchPublicKey(String),
}
impl GetPublicKeyConfigError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetPublicKeyConfigError> {
{
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[..] {
"AccessDenied" => {
return RusotoError::Service(GetPublicKeyConfigError::AccessDenied(
parsed_error.message,
))
}
"NoSuchPublicKey" => {
return RusotoError::Service(GetPublicKeyConfigError::NoSuchPublicKey(
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 GetPublicKeyConfigError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetPublicKeyConfigError::AccessDenied(ref cause) => write!(f, "{}", cause),
GetPublicKeyConfigError::NoSuchPublicKey(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetPublicKeyConfigError {}
#[derive(Debug, PartialEq)]
pub enum GetStreamingDistributionError {
AccessDenied(String),
NoSuchStreamingDistribution(String),
}
impl GetStreamingDistributionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetStreamingDistributionError> {
{
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[..] {
"AccessDenied" => {
return RusotoError::Service(GetStreamingDistributionError::AccessDenied(
parsed_error.message,
))
}
"NoSuchStreamingDistribution" => {
return RusotoError::Service(
GetStreamingDistributionError::NoSuchStreamingDistribution(
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 GetStreamingDistributionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetStreamingDistributionError::AccessDenied(ref cause) => write!(f, "{}", cause),
GetStreamingDistributionError::NoSuchStreamingDistribution(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for GetStreamingDistributionError {}
#[derive(Debug, PartialEq)]
pub enum GetStreamingDistributionConfigError {
AccessDenied(String),
NoSuchStreamingDistribution(String),
}
impl GetStreamingDistributionConfigError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<GetStreamingDistributionConfigError> {
{
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[..] {
"AccessDenied" => {
return RusotoError::Service(
GetStreamingDistributionConfigError::AccessDenied(parsed_error.message),
)
}
"NoSuchStreamingDistribution" => {
return RusotoError::Service(
GetStreamingDistributionConfigError::NoSuchStreamingDistribution(
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 GetStreamingDistributionConfigError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetStreamingDistributionConfigError::AccessDenied(ref cause) => write!(f, "{}", cause),
GetStreamingDistributionConfigError::NoSuchStreamingDistribution(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for GetStreamingDistributionConfigError {}
#[derive(Debug, PartialEq)]
pub enum ListCloudFrontOriginAccessIdentitiesError {
InvalidArgument(String),
}
impl ListCloudFrontOriginAccessIdentitiesError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ListCloudFrontOriginAccessIdentitiesError> {
{
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[..] {
"InvalidArgument" => {
return RusotoError::Service(
ListCloudFrontOriginAccessIdentitiesError::InvalidArgument(
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 ListCloudFrontOriginAccessIdentitiesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListCloudFrontOriginAccessIdentitiesError::InvalidArgument(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for ListCloudFrontOriginAccessIdentitiesError {}
#[derive(Debug, PartialEq)]
pub enum ListDistributionsError {
InvalidArgument(String),
}
impl ListDistributionsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListDistributionsError> {
{
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[..] {
"InvalidArgument" => {
return RusotoError::Service(ListDistributionsError::InvalidArgument(
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 ListDistributionsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListDistributionsError::InvalidArgument(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListDistributionsError {}
#[derive(Debug, PartialEq)]
pub enum ListDistributionsByWebACLIdError {
InvalidArgument(String),
InvalidWebACLId(String),
}
impl ListDistributionsByWebACLIdError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ListDistributionsByWebACLIdError> {
{
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[..] {
"InvalidArgument" => {
return RusotoError::Service(
ListDistributionsByWebACLIdError::InvalidArgument(parsed_error.message),
)
}
"InvalidWebACLId" => {
return RusotoError::Service(
ListDistributionsByWebACLIdError::InvalidWebACLId(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 ListDistributionsByWebACLIdError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListDistributionsByWebACLIdError::InvalidArgument(ref cause) => write!(f, "{}", cause),
ListDistributionsByWebACLIdError::InvalidWebACLId(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListDistributionsByWebACLIdError {}
#[derive(Debug, PartialEq)]
pub enum ListFieldLevelEncryptionConfigsError {
InvalidArgument(String),
}
impl ListFieldLevelEncryptionConfigsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ListFieldLevelEncryptionConfigsError> {
{
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[..] {
"InvalidArgument" => {
return RusotoError::Service(
ListFieldLevelEncryptionConfigsError::InvalidArgument(
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 ListFieldLevelEncryptionConfigsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListFieldLevelEncryptionConfigsError::InvalidArgument(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for ListFieldLevelEncryptionConfigsError {}
#[derive(Debug, PartialEq)]
pub enum ListFieldLevelEncryptionProfilesError {
InvalidArgument(String),
}
impl ListFieldLevelEncryptionProfilesError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ListFieldLevelEncryptionProfilesError> {
{
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[..] {
"InvalidArgument" => {
return RusotoError::Service(
ListFieldLevelEncryptionProfilesError::InvalidArgument(
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 ListFieldLevelEncryptionProfilesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListFieldLevelEncryptionProfilesError::InvalidArgument(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for ListFieldLevelEncryptionProfilesError {}
#[derive(Debug, PartialEq)]
pub enum ListInvalidationsError {
AccessDenied(String),
InvalidArgument(String),
NoSuchDistribution(String),
}
impl ListInvalidationsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListInvalidationsError> {
{
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[..] {
"AccessDenied" => {
return RusotoError::Service(ListInvalidationsError::AccessDenied(
parsed_error.message,
))
}
"InvalidArgument" => {
return RusotoError::Service(ListInvalidationsError::InvalidArgument(
parsed_error.message,
))
}
"NoSuchDistribution" => {
return RusotoError::Service(ListInvalidationsError::NoSuchDistribution(
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 ListInvalidationsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListInvalidationsError::AccessDenied(ref cause) => write!(f, "{}", cause),
ListInvalidationsError::InvalidArgument(ref cause) => write!(f, "{}", cause),
ListInvalidationsError::NoSuchDistribution(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListInvalidationsError {}
#[derive(Debug, PartialEq)]
pub enum ListPublicKeysError {
InvalidArgument(String),
}
impl ListPublicKeysError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListPublicKeysError> {
{
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[..] {
"InvalidArgument" => {
return RusotoError::Service(ListPublicKeysError::InvalidArgument(
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 ListPublicKeysError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListPublicKeysError::InvalidArgument(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListPublicKeysError {}
#[derive(Debug, PartialEq)]
pub enum ListStreamingDistributionsError {
InvalidArgument(String),
}
impl ListStreamingDistributionsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ListStreamingDistributionsError> {
{
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[..] {
"InvalidArgument" => {
return RusotoError::Service(
ListStreamingDistributionsError::InvalidArgument(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 ListStreamingDistributionsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListStreamingDistributionsError::InvalidArgument(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListStreamingDistributionsError {}
#[derive(Debug, PartialEq)]
pub enum ListTagsForResourceError {
AccessDenied(String),
InvalidArgument(String),
InvalidTagging(String),
NoSuchResource(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[..] {
"AccessDenied" => {
return RusotoError::Service(ListTagsForResourceError::AccessDenied(
parsed_error.message,
))
}
"InvalidArgument" => {
return RusotoError::Service(ListTagsForResourceError::InvalidArgument(
parsed_error.message,
))
}
"InvalidTagging" => {
return RusotoError::Service(ListTagsForResourceError::InvalidTagging(
parsed_error.message,
))
}
"NoSuchResource" => {
return RusotoError::Service(ListTagsForResourceError::NoSuchResource(
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::AccessDenied(ref cause) => write!(f, "{}", cause),
ListTagsForResourceError::InvalidArgument(ref cause) => write!(f, "{}", cause),
ListTagsForResourceError::InvalidTagging(ref cause) => write!(f, "{}", cause),
ListTagsForResourceError::NoSuchResource(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListTagsForResourceError {}
#[derive(Debug, PartialEq)]
pub enum TagResourceError {
AccessDenied(String),
InvalidArgument(String),
InvalidTagging(String),
NoSuchResource(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[..] {
"AccessDenied" => {
return RusotoError::Service(TagResourceError::AccessDenied(
parsed_error.message,
))
}
"InvalidArgument" => {
return RusotoError::Service(TagResourceError::InvalidArgument(
parsed_error.message,
))
}
"InvalidTagging" => {
return RusotoError::Service(TagResourceError::InvalidTagging(
parsed_error.message,
))
}
"NoSuchResource" => {
return RusotoError::Service(TagResourceError::NoSuchResource(
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::AccessDenied(ref cause) => write!(f, "{}", cause),
TagResourceError::InvalidArgument(ref cause) => write!(f, "{}", cause),
TagResourceError::InvalidTagging(ref cause) => write!(f, "{}", cause),
TagResourceError::NoSuchResource(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for TagResourceError {}
#[derive(Debug, PartialEq)]
pub enum UntagResourceError {
AccessDenied(String),
InvalidArgument(String),
InvalidTagging(String),
NoSuchResource(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[..] {
"AccessDenied" => {
return RusotoError::Service(UntagResourceError::AccessDenied(
parsed_error.message,
))
}
"InvalidArgument" => {
return RusotoError::Service(UntagResourceError::InvalidArgument(
parsed_error.message,
))
}
"InvalidTagging" => {
return RusotoError::Service(UntagResourceError::InvalidTagging(
parsed_error.message,
))
}
"NoSuchResource" => {
return RusotoError::Service(UntagResourceError::NoSuchResource(
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::AccessDenied(ref cause) => write!(f, "{}", cause),
UntagResourceError::InvalidArgument(ref cause) => write!(f, "{}", cause),
UntagResourceError::InvalidTagging(ref cause) => write!(f, "{}", cause),
UntagResourceError::NoSuchResource(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UntagResourceError {}
#[derive(Debug, PartialEq)]
pub enum UpdateCloudFrontOriginAccessIdentityError {
AccessDenied(String),
IllegalUpdate(String),
InconsistentQuantities(String),
InvalidArgument(String),
InvalidIfMatchVersion(String),
MissingBody(String),
NoSuchCloudFrontOriginAccessIdentity(String),
PreconditionFailed(String),
}
impl UpdateCloudFrontOriginAccessIdentityError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<UpdateCloudFrontOriginAccessIdentityError> {
{
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[..] {
"AccessDenied" => return RusotoError::Service(UpdateCloudFrontOriginAccessIdentityError::AccessDenied(parsed_error.message)),"IllegalUpdate" => return RusotoError::Service(UpdateCloudFrontOriginAccessIdentityError::IllegalUpdate(parsed_error.message)),"InconsistentQuantities" => return RusotoError::Service(UpdateCloudFrontOriginAccessIdentityError::InconsistentQuantities(parsed_error.message)),"InvalidArgument" => return RusotoError::Service(UpdateCloudFrontOriginAccessIdentityError::InvalidArgument(parsed_error.message)),"InvalidIfMatchVersion" => return RusotoError::Service(UpdateCloudFrontOriginAccessIdentityError::InvalidIfMatchVersion(parsed_error.message)),"MissingBody" => return RusotoError::Service(UpdateCloudFrontOriginAccessIdentityError::MissingBody(parsed_error.message)),"NoSuchCloudFrontOriginAccessIdentity" => return RusotoError::Service(UpdateCloudFrontOriginAccessIdentityError::NoSuchCloudFrontOriginAccessIdentity(parsed_error.message)),"PreconditionFailed" => return RusotoError::Service(UpdateCloudFrontOriginAccessIdentityError::PreconditionFailed(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 UpdateCloudFrontOriginAccessIdentityError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateCloudFrontOriginAccessIdentityError::AccessDenied(ref cause) => {
write!(f, "{}", cause)
}
UpdateCloudFrontOriginAccessIdentityError::IllegalUpdate(ref cause) => {
write!(f, "{}", cause)
}
UpdateCloudFrontOriginAccessIdentityError::InconsistentQuantities(ref cause) => {
write!(f, "{}", cause)
}
UpdateCloudFrontOriginAccessIdentityError::InvalidArgument(ref cause) => {
write!(f, "{}", cause)
}
UpdateCloudFrontOriginAccessIdentityError::InvalidIfMatchVersion(ref cause) => {
write!(f, "{}", cause)
}
UpdateCloudFrontOriginAccessIdentityError::MissingBody(ref cause) => {
write!(f, "{}", cause)
}
UpdateCloudFrontOriginAccessIdentityError::NoSuchCloudFrontOriginAccessIdentity(
ref cause,
) => write!(f, "{}", cause),
UpdateCloudFrontOriginAccessIdentityError::PreconditionFailed(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for UpdateCloudFrontOriginAccessIdentityError {}
#[derive(Debug, PartialEq)]
pub enum UpdateDistributionError {
AccessDenied(String),
CNAMEAlreadyExists(String),
IllegalFieldLevelEncryptionConfigAssociationWithCacheBehavior(String),
IllegalUpdate(String),
InconsistentQuantities(String),
InvalidArgument(String),
InvalidDefaultRootObject(String),
InvalidErrorCode(String),
InvalidForwardCookies(String),
InvalidGeoRestrictionParameter(String),
InvalidHeadersForS3Origin(String),
InvalidIfMatchVersion(String),
InvalidLambdaFunctionAssociation(String),
InvalidLocationCode(String),
InvalidMinimumProtocolVersion(String),
InvalidOriginAccessIdentity(String),
InvalidOriginKeepaliveTimeout(String),
InvalidOriginReadTimeout(String),
InvalidQueryStringParameters(String),
InvalidRelativePath(String),
InvalidRequiredProtocol(String),
InvalidResponseCode(String),
InvalidTTLOrder(String),
InvalidViewerCertificate(String),
InvalidWebACLId(String),
MissingBody(String),
NoSuchDistribution(String),
NoSuchFieldLevelEncryptionConfig(String),
NoSuchOrigin(String),
PreconditionFailed(String),
TooManyCacheBehaviors(String),
TooManyCertificates(String),
TooManyCookieNamesInWhiteList(String),
TooManyDistributionCNAMEs(String),
TooManyDistributionsAssociatedToFieldLevelEncryptionConfig(String),
TooManyDistributionsWithLambdaAssociations(String),
TooManyHeadersInForwardedValues(String),
TooManyLambdaFunctionAssociations(String),
TooManyOriginCustomHeaders(String),
TooManyOriginGroupsPerDistribution(String),
TooManyOrigins(String),
TooManyQueryStringParameters(String),
TooManyTrustedSigners(String),
TrustedSignerDoesNotExist(String),
}
impl UpdateDistributionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateDistributionError> {
{
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[..] {
"AccessDenied" => return RusotoError::Service(UpdateDistributionError::AccessDenied(parsed_error.message)),"CNAMEAlreadyExists" => return RusotoError::Service(UpdateDistributionError::CNAMEAlreadyExists(parsed_error.message)),"IllegalFieldLevelEncryptionConfigAssociationWithCacheBehavior" => return RusotoError::Service(UpdateDistributionError::IllegalFieldLevelEncryptionConfigAssociationWithCacheBehavior(parsed_error.message)),"IllegalUpdate" => return RusotoError::Service(UpdateDistributionError::IllegalUpdate(parsed_error.message)),"InconsistentQuantities" => return RusotoError::Service(UpdateDistributionError::InconsistentQuantities(parsed_error.message)),"InvalidArgument" => return RusotoError::Service(UpdateDistributionError::InvalidArgument(parsed_error.message)),"InvalidDefaultRootObject" => return RusotoError::Service(UpdateDistributionError::InvalidDefaultRootObject(parsed_error.message)),"InvalidErrorCode" => return RusotoError::Service(UpdateDistributionError::InvalidErrorCode(parsed_error.message)),"InvalidForwardCookies" => return RusotoError::Service(UpdateDistributionError::InvalidForwardCookies(parsed_error.message)),"InvalidGeoRestrictionParameter" => return RusotoError::Service(UpdateDistributionError::InvalidGeoRestrictionParameter(parsed_error.message)),"InvalidHeadersForS3Origin" => return RusotoError::Service(UpdateDistributionError::InvalidHeadersForS3Origin(parsed_error.message)),"InvalidIfMatchVersion" => return RusotoError::Service(UpdateDistributionError::InvalidIfMatchVersion(parsed_error.message)),"InvalidLambdaFunctionAssociation" => return RusotoError::Service(UpdateDistributionError::InvalidLambdaFunctionAssociation(parsed_error.message)),"InvalidLocationCode" => return RusotoError::Service(UpdateDistributionError::InvalidLocationCode(parsed_error.message)),"InvalidMinimumProtocolVersion" => return RusotoError::Service(UpdateDistributionError::InvalidMinimumProtocolVersion(parsed_error.message)),"InvalidOriginAccessIdentity" => return RusotoError::Service(UpdateDistributionError::InvalidOriginAccessIdentity(parsed_error.message)),"InvalidOriginKeepaliveTimeout" => return RusotoError::Service(UpdateDistributionError::InvalidOriginKeepaliveTimeout(parsed_error.message)),"InvalidOriginReadTimeout" => return RusotoError::Service(UpdateDistributionError::InvalidOriginReadTimeout(parsed_error.message)),"InvalidQueryStringParameters" => return RusotoError::Service(UpdateDistributionError::InvalidQueryStringParameters(parsed_error.message)),"InvalidRelativePath" => return RusotoError::Service(UpdateDistributionError::InvalidRelativePath(parsed_error.message)),"InvalidRequiredProtocol" => return RusotoError::Service(UpdateDistributionError::InvalidRequiredProtocol(parsed_error.message)),"InvalidResponseCode" => return RusotoError::Service(UpdateDistributionError::InvalidResponseCode(parsed_error.message)),"InvalidTTLOrder" => return RusotoError::Service(UpdateDistributionError::InvalidTTLOrder(parsed_error.message)),"InvalidViewerCertificate" => return RusotoError::Service(UpdateDistributionError::InvalidViewerCertificate(parsed_error.message)),"InvalidWebACLId" => return RusotoError::Service(UpdateDistributionError::InvalidWebACLId(parsed_error.message)),"MissingBody" => return RusotoError::Service(UpdateDistributionError::MissingBody(parsed_error.message)),"NoSuchDistribution" => return RusotoError::Service(UpdateDistributionError::NoSuchDistribution(parsed_error.message)),"NoSuchFieldLevelEncryptionConfig" => return RusotoError::Service(UpdateDistributionError::NoSuchFieldLevelEncryptionConfig(parsed_error.message)),"NoSuchOrigin" => return RusotoError::Service(UpdateDistributionError::NoSuchOrigin(parsed_error.message)),"PreconditionFailed" => return RusotoError::Service(UpdateDistributionError::PreconditionFailed(parsed_error.message)),"TooManyCacheBehaviors" => return RusotoError::Service(UpdateDistributionError::TooManyCacheBehaviors(parsed_error.message)),"TooManyCertificates" => return RusotoError::Service(UpdateDistributionError::TooManyCertificates(parsed_error.message)),"TooManyCookieNamesInWhiteList" => return RusotoError::Service(UpdateDistributionError::TooManyCookieNamesInWhiteList(parsed_error.message)),"TooManyDistributionCNAMEs" => return RusotoError::Service(UpdateDistributionError::TooManyDistributionCNAMEs(parsed_error.message)),"TooManyDistributionsAssociatedToFieldLevelEncryptionConfig" => return RusotoError::Service(UpdateDistributionError::TooManyDistributionsAssociatedToFieldLevelEncryptionConfig(parsed_error.message)),"TooManyDistributionsWithLambdaAssociations" => return RusotoError::Service(UpdateDistributionError::TooManyDistributionsWithLambdaAssociations(parsed_error.message)),"TooManyHeadersInForwardedValues" => return RusotoError::Service(UpdateDistributionError::TooManyHeadersInForwardedValues(parsed_error.message)),"TooManyLambdaFunctionAssociations" => return RusotoError::Service(UpdateDistributionError::TooManyLambdaFunctionAssociations(parsed_error.message)),"TooManyOriginCustomHeaders" => return RusotoError::Service(UpdateDistributionError::TooManyOriginCustomHeaders(parsed_error.message)),"TooManyOriginGroupsPerDistribution" => return RusotoError::Service(UpdateDistributionError::TooManyOriginGroupsPerDistribution(parsed_error.message)),"TooManyOrigins" => return RusotoError::Service(UpdateDistributionError::TooManyOrigins(parsed_error.message)),"TooManyQueryStringParameters" => return RusotoError::Service(UpdateDistributionError::TooManyQueryStringParameters(parsed_error.message)),"TooManyTrustedSigners" => return RusotoError::Service(UpdateDistributionError::TooManyTrustedSigners(parsed_error.message)),"TrustedSignerDoesNotExist" => return RusotoError::Service(UpdateDistributionError::TrustedSignerDoesNotExist(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 UpdateDistributionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateDistributionError::AccessDenied(ref cause) => write!(f, "{}", cause),
UpdateDistributionError::CNAMEAlreadyExists(ref cause) => write!(f, "{}", cause),
UpdateDistributionError::IllegalFieldLevelEncryptionConfigAssociationWithCacheBehavior(ref cause) => write!(f, "{}", cause),
UpdateDistributionError::IllegalUpdate(ref cause) => write!(f, "{}", cause),
UpdateDistributionError::InconsistentQuantities(ref cause) => write!(f, "{}", cause),
UpdateDistributionError::InvalidArgument(ref cause) => write!(f, "{}", cause),
UpdateDistributionError::InvalidDefaultRootObject(ref cause) => write!(f, "{}", cause),
UpdateDistributionError::InvalidErrorCode(ref cause) => write!(f, "{}", cause),
UpdateDistributionError::InvalidForwardCookies(ref cause) => write!(f, "{}", cause),
UpdateDistributionError::InvalidGeoRestrictionParameter(ref cause) => write!(f, "{}", cause),
UpdateDistributionError::InvalidHeadersForS3Origin(ref cause) => write!(f, "{}", cause),
UpdateDistributionError::InvalidIfMatchVersion(ref cause) => write!(f, "{}", cause),
UpdateDistributionError::InvalidLambdaFunctionAssociation(ref cause) => write!(f, "{}", cause),
UpdateDistributionError::InvalidLocationCode(ref cause) => write!(f, "{}", cause),
UpdateDistributionError::InvalidMinimumProtocolVersion(ref cause) => write!(f, "{}", cause),
UpdateDistributionError::InvalidOriginAccessIdentity(ref cause) => write!(f, "{}", cause),
UpdateDistributionError::InvalidOriginKeepaliveTimeout(ref cause) => write!(f, "{}", cause),
UpdateDistributionError::InvalidOriginReadTimeout(ref cause) => write!(f, "{}", cause),
UpdateDistributionError::InvalidQueryStringParameters(ref cause) => write!(f, "{}", cause),
UpdateDistributionError::InvalidRelativePath(ref cause) => write!(f, "{}", cause),
UpdateDistributionError::InvalidRequiredProtocol(ref cause) => write!(f, "{}", cause),
UpdateDistributionError::InvalidResponseCode(ref cause) => write!(f, "{}", cause),
UpdateDistributionError::InvalidTTLOrder(ref cause) => write!(f, "{}", cause),
UpdateDistributionError::InvalidViewerCertificate(ref cause) => write!(f, "{}", cause),
UpdateDistributionError::InvalidWebACLId(ref cause) => write!(f, "{}", cause),
UpdateDistributionError::MissingBody(ref cause) => write!(f, "{}", cause),
UpdateDistributionError::NoSuchDistribution(ref cause) => write!(f, "{}", cause),
UpdateDistributionError::NoSuchFieldLevelEncryptionConfig(ref cause) => write!(f, "{}", cause),
UpdateDistributionError::NoSuchOrigin(ref cause) => write!(f, "{}", cause),
UpdateDistributionError::PreconditionFailed(ref cause) => write!(f, "{}", cause),
UpdateDistributionError::TooManyCacheBehaviors(ref cause) => write!(f, "{}", cause),
UpdateDistributionError::TooManyCertificates(ref cause) => write!(f, "{}", cause),
UpdateDistributionError::TooManyCookieNamesInWhiteList(ref cause) => write!(f, "{}", cause),
UpdateDistributionError::TooManyDistributionCNAMEs(ref cause) => write!(f, "{}", cause),
UpdateDistributionError::TooManyDistributionsAssociatedToFieldLevelEncryptionConfig(ref cause) => write!(f, "{}", cause),
UpdateDistributionError::TooManyDistributionsWithLambdaAssociations(ref cause) => write!(f, "{}", cause),
UpdateDistributionError::TooManyHeadersInForwardedValues(ref cause) => write!(f, "{}", cause),
UpdateDistributionError::TooManyLambdaFunctionAssociations(ref cause) => write!(f, "{}", cause),
UpdateDistributionError::TooManyOriginCustomHeaders(ref cause) => write!(f, "{}", cause),
UpdateDistributionError::TooManyOriginGroupsPerDistribution(ref cause) => write!(f, "{}", cause),
UpdateDistributionError::TooManyOrigins(ref cause) => write!(f, "{}", cause),
UpdateDistributionError::TooManyQueryStringParameters(ref cause) => write!(f, "{}", cause),
UpdateDistributionError::TooManyTrustedSigners(ref cause) => write!(f, "{}", cause),
UpdateDistributionError::TrustedSignerDoesNotExist(ref cause) => write!(f, "{}", cause)
}
}
}
impl Error for UpdateDistributionError {}
#[derive(Debug, PartialEq)]
pub enum UpdateFieldLevelEncryptionConfigError {
AccessDenied(String),
IllegalUpdate(String),
InconsistentQuantities(String),
InvalidArgument(String),
InvalidIfMatchVersion(String),
NoSuchFieldLevelEncryptionConfig(String),
NoSuchFieldLevelEncryptionProfile(String),
PreconditionFailed(String),
QueryArgProfileEmpty(String),
TooManyFieldLevelEncryptionContentTypeProfiles(String),
TooManyFieldLevelEncryptionQueryArgProfiles(String),
}
impl UpdateFieldLevelEncryptionConfigError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<UpdateFieldLevelEncryptionConfigError> {
{
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[..] {
"AccessDenied" => return RusotoError::Service(UpdateFieldLevelEncryptionConfigError::AccessDenied(parsed_error.message)),"IllegalUpdate" => return RusotoError::Service(UpdateFieldLevelEncryptionConfigError::IllegalUpdate(parsed_error.message)),"InconsistentQuantities" => return RusotoError::Service(UpdateFieldLevelEncryptionConfigError::InconsistentQuantities(parsed_error.message)),"InvalidArgument" => return RusotoError::Service(UpdateFieldLevelEncryptionConfigError::InvalidArgument(parsed_error.message)),"InvalidIfMatchVersion" => return RusotoError::Service(UpdateFieldLevelEncryptionConfigError::InvalidIfMatchVersion(parsed_error.message)),"NoSuchFieldLevelEncryptionConfig" => return RusotoError::Service(UpdateFieldLevelEncryptionConfigError::NoSuchFieldLevelEncryptionConfig(parsed_error.message)),"NoSuchFieldLevelEncryptionProfile" => return RusotoError::Service(UpdateFieldLevelEncryptionConfigError::NoSuchFieldLevelEncryptionProfile(parsed_error.message)),"PreconditionFailed" => return RusotoError::Service(UpdateFieldLevelEncryptionConfigError::PreconditionFailed(parsed_error.message)),"QueryArgProfileEmpty" => return RusotoError::Service(UpdateFieldLevelEncryptionConfigError::QueryArgProfileEmpty(parsed_error.message)),"TooManyFieldLevelEncryptionContentTypeProfiles" => return RusotoError::Service(UpdateFieldLevelEncryptionConfigError::TooManyFieldLevelEncryptionContentTypeProfiles(parsed_error.message)),"TooManyFieldLevelEncryptionQueryArgProfiles" => return RusotoError::Service(UpdateFieldLevelEncryptionConfigError::TooManyFieldLevelEncryptionQueryArgProfiles(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 UpdateFieldLevelEncryptionConfigError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateFieldLevelEncryptionConfigError::AccessDenied(ref cause) => write!(f, "{}", cause),
UpdateFieldLevelEncryptionConfigError::IllegalUpdate(ref cause) => write!(f, "{}", cause),
UpdateFieldLevelEncryptionConfigError::InconsistentQuantities(ref cause) => write!(f, "{}", cause),
UpdateFieldLevelEncryptionConfigError::InvalidArgument(ref cause) => write!(f, "{}", cause),
UpdateFieldLevelEncryptionConfigError::InvalidIfMatchVersion(ref cause) => write!(f, "{}", cause),
UpdateFieldLevelEncryptionConfigError::NoSuchFieldLevelEncryptionConfig(ref cause) => write!(f, "{}", cause),
UpdateFieldLevelEncryptionConfigError::NoSuchFieldLevelEncryptionProfile(ref cause) => write!(f, "{}", cause),
UpdateFieldLevelEncryptionConfigError::PreconditionFailed(ref cause) => write!(f, "{}", cause),
UpdateFieldLevelEncryptionConfigError::QueryArgProfileEmpty(ref cause) => write!(f, "{}", cause),
UpdateFieldLevelEncryptionConfigError::TooManyFieldLevelEncryptionContentTypeProfiles(ref cause) => write!(f, "{}", cause),
UpdateFieldLevelEncryptionConfigError::TooManyFieldLevelEncryptionQueryArgProfiles(ref cause) => write!(f, "{}", cause)
}
}
}
impl Error for UpdateFieldLevelEncryptionConfigError {}
#[derive(Debug, PartialEq)]
pub enum UpdateFieldLevelEncryptionProfileError {
AccessDenied(String),
FieldLevelEncryptionProfileAlreadyExists(String),
FieldLevelEncryptionProfileSizeExceeded(String),
IllegalUpdate(String),
InconsistentQuantities(String),
InvalidArgument(String),
InvalidIfMatchVersion(String),
NoSuchFieldLevelEncryptionProfile(String),
NoSuchPublicKey(String),
PreconditionFailed(String),
TooManyFieldLevelEncryptionEncryptionEntities(String),
TooManyFieldLevelEncryptionFieldPatterns(String),
}
impl UpdateFieldLevelEncryptionProfileError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<UpdateFieldLevelEncryptionProfileError> {
{
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[..] {
"AccessDenied" => return RusotoError::Service(UpdateFieldLevelEncryptionProfileError::AccessDenied(parsed_error.message)),"FieldLevelEncryptionProfileAlreadyExists" => return RusotoError::Service(UpdateFieldLevelEncryptionProfileError::FieldLevelEncryptionProfileAlreadyExists(parsed_error.message)),"FieldLevelEncryptionProfileSizeExceeded" => return RusotoError::Service(UpdateFieldLevelEncryptionProfileError::FieldLevelEncryptionProfileSizeExceeded(parsed_error.message)),"IllegalUpdate" => return RusotoError::Service(UpdateFieldLevelEncryptionProfileError::IllegalUpdate(parsed_error.message)),"InconsistentQuantities" => return RusotoError::Service(UpdateFieldLevelEncryptionProfileError::InconsistentQuantities(parsed_error.message)),"InvalidArgument" => return RusotoError::Service(UpdateFieldLevelEncryptionProfileError::InvalidArgument(parsed_error.message)),"InvalidIfMatchVersion" => return RusotoError::Service(UpdateFieldLevelEncryptionProfileError::InvalidIfMatchVersion(parsed_error.message)),"NoSuchFieldLevelEncryptionProfile" => return RusotoError::Service(UpdateFieldLevelEncryptionProfileError::NoSuchFieldLevelEncryptionProfile(parsed_error.message)),"NoSuchPublicKey" => return RusotoError::Service(UpdateFieldLevelEncryptionProfileError::NoSuchPublicKey(parsed_error.message)),"PreconditionFailed" => return RusotoError::Service(UpdateFieldLevelEncryptionProfileError::PreconditionFailed(parsed_error.message)),"TooManyFieldLevelEncryptionEncryptionEntities" => return RusotoError::Service(UpdateFieldLevelEncryptionProfileError::TooManyFieldLevelEncryptionEncryptionEntities(parsed_error.message)),"TooManyFieldLevelEncryptionFieldPatterns" => return RusotoError::Service(UpdateFieldLevelEncryptionProfileError::TooManyFieldLevelEncryptionFieldPatterns(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 UpdateFieldLevelEncryptionProfileError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateFieldLevelEncryptionProfileError::AccessDenied(ref cause) => write!(f, "{}", cause),
UpdateFieldLevelEncryptionProfileError::FieldLevelEncryptionProfileAlreadyExists(ref cause) => write!(f, "{}", cause),
UpdateFieldLevelEncryptionProfileError::FieldLevelEncryptionProfileSizeExceeded(ref cause) => write!(f, "{}", cause),
UpdateFieldLevelEncryptionProfileError::IllegalUpdate(ref cause) => write!(f, "{}", cause),
UpdateFieldLevelEncryptionProfileError::InconsistentQuantities(ref cause) => write!(f, "{}", cause),
UpdateFieldLevelEncryptionProfileError::InvalidArgument(ref cause) => write!(f, "{}", cause),
UpdateFieldLevelEncryptionProfileError::InvalidIfMatchVersion(ref cause) => write!(f, "{}", cause),
UpdateFieldLevelEncryptionProfileError::NoSuchFieldLevelEncryptionProfile(ref cause) => write!(f, "{}", cause),
UpdateFieldLevelEncryptionProfileError::NoSuchPublicKey(ref cause) => write!(f, "{}", cause),
UpdateFieldLevelEncryptionProfileError::PreconditionFailed(ref cause) => write!(f, "{}", cause),
UpdateFieldLevelEncryptionProfileError::TooManyFieldLevelEncryptionEncryptionEntities(ref cause) => write!(f, "{}", cause),
UpdateFieldLevelEncryptionProfileError::TooManyFieldLevelEncryptionFieldPatterns(ref cause) => write!(f, "{}", cause)
}
}
}
impl Error for UpdateFieldLevelEncryptionProfileError {}
#[derive(Debug, PartialEq)]
pub enum UpdatePublicKeyError {
AccessDenied(String),
CannotChangeImmutablePublicKeyFields(String),
IllegalUpdate(String),
InvalidArgument(String),
InvalidIfMatchVersion(String),
NoSuchPublicKey(String),
PreconditionFailed(String),
}
impl UpdatePublicKeyError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdatePublicKeyError> {
{
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[..] {
"AccessDenied" => {
return RusotoError::Service(UpdatePublicKeyError::AccessDenied(
parsed_error.message,
))
}
"CannotChangeImmutablePublicKeyFields" => {
return RusotoError::Service(
UpdatePublicKeyError::CannotChangeImmutablePublicKeyFields(
parsed_error.message,
),
)
}
"IllegalUpdate" => {
return RusotoError::Service(UpdatePublicKeyError::IllegalUpdate(
parsed_error.message,
))
}
"InvalidArgument" => {
return RusotoError::Service(UpdatePublicKeyError::InvalidArgument(
parsed_error.message,
))
}
"InvalidIfMatchVersion" => {
return RusotoError::Service(UpdatePublicKeyError::InvalidIfMatchVersion(
parsed_error.message,
))
}
"NoSuchPublicKey" => {
return RusotoError::Service(UpdatePublicKeyError::NoSuchPublicKey(
parsed_error.message,
))
}
"PreconditionFailed" => {
return RusotoError::Service(UpdatePublicKeyError::PreconditionFailed(
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 UpdatePublicKeyError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdatePublicKeyError::AccessDenied(ref cause) => write!(f, "{}", cause),
UpdatePublicKeyError::CannotChangeImmutablePublicKeyFields(ref cause) => {
write!(f, "{}", cause)
}
UpdatePublicKeyError::IllegalUpdate(ref cause) => write!(f, "{}", cause),
UpdatePublicKeyError::InvalidArgument(ref cause) => write!(f, "{}", cause),
UpdatePublicKeyError::InvalidIfMatchVersion(ref cause) => write!(f, "{}", cause),
UpdatePublicKeyError::NoSuchPublicKey(ref cause) => write!(f, "{}", cause),
UpdatePublicKeyError::PreconditionFailed(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdatePublicKeyError {}
#[derive(Debug, PartialEq)]
pub enum UpdateStreamingDistributionError {
AccessDenied(String),
CNAMEAlreadyExists(String),
IllegalUpdate(String),
InconsistentQuantities(String),
InvalidArgument(String),
InvalidIfMatchVersion(String),
InvalidOriginAccessIdentity(String),
MissingBody(String),
NoSuchStreamingDistribution(String),
PreconditionFailed(String),
TooManyStreamingDistributionCNAMEs(String),
TooManyTrustedSigners(String),
TrustedSignerDoesNotExist(String),
}
impl UpdateStreamingDistributionError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<UpdateStreamingDistributionError> {
{
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[..] {
"AccessDenied" => {
return RusotoError::Service(
UpdateStreamingDistributionError::AccessDenied(parsed_error.message),
)
}
"CNAMEAlreadyExists" => {
return RusotoError::Service(
UpdateStreamingDistributionError::CNAMEAlreadyExists(
parsed_error.message,
),
)
}
"IllegalUpdate" => {
return RusotoError::Service(
UpdateStreamingDistributionError::IllegalUpdate(parsed_error.message),
)
}
"InconsistentQuantities" => {
return RusotoError::Service(
UpdateStreamingDistributionError::InconsistentQuantities(
parsed_error.message,
),
)
}
"InvalidArgument" => {
return RusotoError::Service(
UpdateStreamingDistributionError::InvalidArgument(parsed_error.message),
)
}
"InvalidIfMatchVersion" => {
return RusotoError::Service(
UpdateStreamingDistributionError::InvalidIfMatchVersion(
parsed_error.message,
),
)
}
"InvalidOriginAccessIdentity" => {
return RusotoError::Service(
UpdateStreamingDistributionError::InvalidOriginAccessIdentity(
parsed_error.message,
),
)
}
"MissingBody" => {
return RusotoError::Service(UpdateStreamingDistributionError::MissingBody(
parsed_error.message,
))
}
"NoSuchStreamingDistribution" => {
return RusotoError::Service(
UpdateStreamingDistributionError::NoSuchStreamingDistribution(
parsed_error.message,
),
)
}
"PreconditionFailed" => {
return RusotoError::Service(
UpdateStreamingDistributionError::PreconditionFailed(
parsed_error.message,
),
)
}
"TooManyStreamingDistributionCNAMEs" => {
return RusotoError::Service(
UpdateStreamingDistributionError::TooManyStreamingDistributionCNAMEs(
parsed_error.message,
),
)
}
"TooManyTrustedSigners" => {
return RusotoError::Service(
UpdateStreamingDistributionError::TooManyTrustedSigners(
parsed_error.message,
),
)
}
"TrustedSignerDoesNotExist" => {
return RusotoError::Service(
UpdateStreamingDistributionError::TrustedSignerDoesNotExist(
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 UpdateStreamingDistributionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateStreamingDistributionError::AccessDenied(ref cause) => write!(f, "{}", cause),
UpdateStreamingDistributionError::CNAMEAlreadyExists(ref cause) => {
write!(f, "{}", cause)
}
UpdateStreamingDistributionError::IllegalUpdate(ref cause) => write!(f, "{}", cause),
UpdateStreamingDistributionError::InconsistentQuantities(ref cause) => {
write!(f, "{}", cause)
}
UpdateStreamingDistributionError::InvalidArgument(ref cause) => write!(f, "{}", cause),
UpdateStreamingDistributionError::InvalidIfMatchVersion(ref cause) => {
write!(f, "{}", cause)
}
UpdateStreamingDistributionError::InvalidOriginAccessIdentity(ref cause) => {
write!(f, "{}", cause)
}
UpdateStreamingDistributionError::MissingBody(ref cause) => write!(f, "{}", cause),
UpdateStreamingDistributionError::NoSuchStreamingDistribution(ref cause) => {
write!(f, "{}", cause)
}
UpdateStreamingDistributionError::PreconditionFailed(ref cause) => {
write!(f, "{}", cause)
}
UpdateStreamingDistributionError::TooManyStreamingDistributionCNAMEs(ref cause) => {
write!(f, "{}", cause)
}
UpdateStreamingDistributionError::TooManyTrustedSigners(ref cause) => {
write!(f, "{}", cause)
}
UpdateStreamingDistributionError::TrustedSignerDoesNotExist(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for UpdateStreamingDistributionError {}
#[async_trait]
pub trait CloudFront {
async fn create_cloud_front_origin_access_identity(
&self,
input: CreateCloudFrontOriginAccessIdentityRequest,
) -> Result<
CreateCloudFrontOriginAccessIdentityResult,
RusotoError<CreateCloudFrontOriginAccessIdentityError>,
>;
async fn create_distribution(
&self,
input: CreateDistributionRequest,
) -> Result<CreateDistributionResult, RusotoError<CreateDistributionError>>;
async fn create_distribution_with_tags(
&self,
input: CreateDistributionWithTagsRequest,
) -> Result<CreateDistributionWithTagsResult, RusotoError<CreateDistributionWithTagsError>>;
async fn create_field_level_encryption_config(
&self,
input: CreateFieldLevelEncryptionConfigRequest,
) -> Result<
CreateFieldLevelEncryptionConfigResult,
RusotoError<CreateFieldLevelEncryptionConfigError>,
>;
async fn create_field_level_encryption_profile(
&self,
input: CreateFieldLevelEncryptionProfileRequest,
) -> Result<
CreateFieldLevelEncryptionProfileResult,
RusotoError<CreateFieldLevelEncryptionProfileError>,
>;
async fn create_invalidation(
&self,
input: CreateInvalidationRequest,
) -> Result<CreateInvalidationResult, RusotoError<CreateInvalidationError>>;
async fn create_public_key(
&self,
input: CreatePublicKeyRequest,
) -> Result<CreatePublicKeyResult, RusotoError<CreatePublicKeyError>>;
async fn create_streaming_distribution(
&self,
input: CreateStreamingDistributionRequest,
) -> Result<CreateStreamingDistributionResult, RusotoError<CreateStreamingDistributionError>>;
async fn create_streaming_distribution_with_tags(
&self,
input: CreateStreamingDistributionWithTagsRequest,
) -> Result<
CreateStreamingDistributionWithTagsResult,
RusotoError<CreateStreamingDistributionWithTagsError>,
>;
async fn delete_cloud_front_origin_access_identity(
&self,
input: DeleteCloudFrontOriginAccessIdentityRequest,
) -> Result<(), RusotoError<DeleteCloudFrontOriginAccessIdentityError>>;
async fn delete_distribution(
&self,
input: DeleteDistributionRequest,
) -> Result<(), RusotoError<DeleteDistributionError>>;
async fn delete_field_level_encryption_config(
&self,
input: DeleteFieldLevelEncryptionConfigRequest,
) -> Result<(), RusotoError<DeleteFieldLevelEncryptionConfigError>>;
async fn delete_field_level_encryption_profile(
&self,
input: DeleteFieldLevelEncryptionProfileRequest,
) -> Result<(), RusotoError<DeleteFieldLevelEncryptionProfileError>>;
async fn delete_public_key(
&self,
input: DeletePublicKeyRequest,
) -> Result<(), RusotoError<DeletePublicKeyError>>;
async fn delete_streaming_distribution(
&self,
input: DeleteStreamingDistributionRequest,
) -> Result<(), RusotoError<DeleteStreamingDistributionError>>;
async fn get_cloud_front_origin_access_identity(
&self,
input: GetCloudFrontOriginAccessIdentityRequest,
) -> Result<
GetCloudFrontOriginAccessIdentityResult,
RusotoError<GetCloudFrontOriginAccessIdentityError>,
>;
async fn get_cloud_front_origin_access_identity_config(
&self,
input: GetCloudFrontOriginAccessIdentityConfigRequest,
) -> Result<
GetCloudFrontOriginAccessIdentityConfigResult,
RusotoError<GetCloudFrontOriginAccessIdentityConfigError>,
>;
async fn get_distribution(
&self,
input: GetDistributionRequest,
) -> Result<GetDistributionResult, RusotoError<GetDistributionError>>;
async fn get_distribution_config(
&self,
input: GetDistributionConfigRequest,
) -> Result<GetDistributionConfigResult, RusotoError<GetDistributionConfigError>>;
async fn get_field_level_encryption(
&self,
input: GetFieldLevelEncryptionRequest,
) -> Result<GetFieldLevelEncryptionResult, RusotoError<GetFieldLevelEncryptionError>>;
async fn get_field_level_encryption_config(
&self,
input: GetFieldLevelEncryptionConfigRequest,
) -> Result<GetFieldLevelEncryptionConfigResult, RusotoError<GetFieldLevelEncryptionConfigError>>;
async fn get_field_level_encryption_profile(
&self,
input: GetFieldLevelEncryptionProfileRequest,
) -> Result<
GetFieldLevelEncryptionProfileResult,
RusotoError<GetFieldLevelEncryptionProfileError>,
>;
async fn get_field_level_encryption_profile_config(
&self,
input: GetFieldLevelEncryptionProfileConfigRequest,
) -> Result<
GetFieldLevelEncryptionProfileConfigResult,
RusotoError<GetFieldLevelEncryptionProfileConfigError>,
>;
async fn get_invalidation(
&self,
input: GetInvalidationRequest,
) -> Result<GetInvalidationResult, RusotoError<GetInvalidationError>>;
async fn get_public_key(
&self,
input: GetPublicKeyRequest,
) -> Result<GetPublicKeyResult, RusotoError<GetPublicKeyError>>;
async fn get_public_key_config(
&self,
input: GetPublicKeyConfigRequest,
) -> Result<GetPublicKeyConfigResult, RusotoError<GetPublicKeyConfigError>>;
async fn get_streaming_distribution(
&self,
input: GetStreamingDistributionRequest,
) -> Result<GetStreamingDistributionResult, RusotoError<GetStreamingDistributionError>>;
async fn get_streaming_distribution_config(
&self,
input: GetStreamingDistributionConfigRequest,
) -> Result<
GetStreamingDistributionConfigResult,
RusotoError<GetStreamingDistributionConfigError>,
>;
async fn list_cloud_front_origin_access_identities(
&self,
input: ListCloudFrontOriginAccessIdentitiesRequest,
) -> Result<
ListCloudFrontOriginAccessIdentitiesResult,
RusotoError<ListCloudFrontOriginAccessIdentitiesError>,
>;
async fn list_distributions(
&self,
input: ListDistributionsRequest,
) -> Result<ListDistributionsResult, RusotoError<ListDistributionsError>>;
async fn list_distributions_by_web_acl_id(
&self,
input: ListDistributionsByWebACLIdRequest,
) -> Result<ListDistributionsByWebACLIdResult, RusotoError<ListDistributionsByWebACLIdError>>;
async fn list_field_level_encryption_configs(
&self,
input: ListFieldLevelEncryptionConfigsRequest,
) -> Result<
ListFieldLevelEncryptionConfigsResult,
RusotoError<ListFieldLevelEncryptionConfigsError>,
>;
async fn list_field_level_encryption_profiles(
&self,
input: ListFieldLevelEncryptionProfilesRequest,
) -> Result<
ListFieldLevelEncryptionProfilesResult,
RusotoError<ListFieldLevelEncryptionProfilesError>,
>;
async fn list_invalidations(
&self,
input: ListInvalidationsRequest,
) -> Result<ListInvalidationsResult, RusotoError<ListInvalidationsError>>;
async fn list_public_keys(
&self,
input: ListPublicKeysRequest,
) -> Result<ListPublicKeysResult, RusotoError<ListPublicKeysError>>;
async fn list_streaming_distributions(
&self,
input: ListStreamingDistributionsRequest,
) -> Result<ListStreamingDistributionsResult, RusotoError<ListStreamingDistributionsError>>;
async fn list_tags_for_resource(
&self,
input: ListTagsForResourceRequest,
) -> Result<ListTagsForResourceResult, RusotoError<ListTagsForResourceError>>;
async fn tag_resource(
&self,
input: TagResourceRequest,
) -> Result<(), RusotoError<TagResourceError>>;
async fn untag_resource(
&self,
input: UntagResourceRequest,
) -> Result<(), RusotoError<UntagResourceError>>;
async fn update_cloud_front_origin_access_identity(
&self,
input: UpdateCloudFrontOriginAccessIdentityRequest,
) -> Result<
UpdateCloudFrontOriginAccessIdentityResult,
RusotoError<UpdateCloudFrontOriginAccessIdentityError>,
>;
async fn update_distribution(
&self,
input: UpdateDistributionRequest,
) -> Result<UpdateDistributionResult, RusotoError<UpdateDistributionError>>;
async fn update_field_level_encryption_config(
&self,
input: UpdateFieldLevelEncryptionConfigRequest,
) -> Result<
UpdateFieldLevelEncryptionConfigResult,
RusotoError<UpdateFieldLevelEncryptionConfigError>,
>;
async fn update_field_level_encryption_profile(
&self,
input: UpdateFieldLevelEncryptionProfileRequest,
) -> Result<
UpdateFieldLevelEncryptionProfileResult,
RusotoError<UpdateFieldLevelEncryptionProfileError>,
>;
async fn update_public_key(
&self,
input: UpdatePublicKeyRequest,
) -> Result<UpdatePublicKeyResult, RusotoError<UpdatePublicKeyError>>;
async fn update_streaming_distribution(
&self,
input: UpdateStreamingDistributionRequest,
) -> Result<UpdateStreamingDistributionResult, RusotoError<UpdateStreamingDistributionError>>;
}
#[derive(Clone)]
pub struct CloudFrontClient {
client: Client,
region: region::Region,
}
impl CloudFrontClient {
pub fn new(region: region::Region) -> CloudFrontClient {
CloudFrontClient {
client: Client::shared(),
region,
}
}
pub fn new_with<P, D>(
request_dispatcher: D,
credentials_provider: P,
region: region::Region,
) -> CloudFrontClient
where
P: ProvideAwsCredentials + Send + Sync + 'static,
D: DispatchSignedRequest + Send + Sync + 'static,
{
CloudFrontClient {
client: Client::new_with(credentials_provider, request_dispatcher),
region,
}
}
pub fn new_with_client(client: Client, region: region::Region) -> CloudFrontClient {
CloudFrontClient { client, region }
}
}
#[async_trait]
impl CloudFront for CloudFrontClient {
#[allow(unused_variables, warnings)]
async fn create_cloud_front_origin_access_identity(
&self,
input: CreateCloudFrontOriginAccessIdentityRequest,
) -> Result<
CreateCloudFrontOriginAccessIdentityResult,
RusotoError<CreateCloudFrontOriginAccessIdentityError>,
> {
let request_uri = "/2019-03-26/origin-access-identity/cloudfront";
let mut request = SignedRequest::new("POST", "cloudfront", &self.region, &request_uri);
let mut writer = EventWriter::new(Vec::new());
CloudFrontOriginAccessIdentityConfigSerializer::serialize(
&mut writer,
"CloudFrontOriginAccessIdentityConfig",
&input.cloud_front_origin_access_identity_config,
);
request.set_payload(Some(writer.into_inner()));
let mut response = self
.sign_and_dispatch(
request,
CreateCloudFrontOriginAccessIdentityError::from_response,
)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
CreateCloudFrontOriginAccessIdentityResultDeserializer::deserialize(
actual_tag_name,
stack,
)
})
.await?;
let mut result = result;
result.e_tag = response.headers.remove("ETag");
result.location = response.headers.remove("Location");
Ok(result)
}
#[allow(unused_variables, warnings)]
async fn create_distribution(
&self,
input: CreateDistributionRequest,
) -> Result<CreateDistributionResult, RusotoError<CreateDistributionError>> {
let request_uri = "/2019-03-26/distribution";
let mut request = SignedRequest::new("POST", "cloudfront", &self.region, &request_uri);
let mut writer = EventWriter::new(Vec::new());
DistributionConfigSerializer::serialize(
&mut writer,
"DistributionConfig",
&input.distribution_config,
);
request.set_payload(Some(writer.into_inner()));
let mut response = self
.sign_and_dispatch(request, CreateDistributionError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
CreateDistributionResultDeserializer::deserialize(actual_tag_name, stack)
})
.await?;
let mut result = result;
result.e_tag = response.headers.remove("ETag");
result.location = response.headers.remove("Location");
Ok(result)
}
#[allow(unused_variables, warnings)]
async fn create_distribution_with_tags(
&self,
input: CreateDistributionWithTagsRequest,
) -> Result<CreateDistributionWithTagsResult, RusotoError<CreateDistributionWithTagsError>>
{
let request_uri = "/2019-03-26/distribution";
let mut request = SignedRequest::new("POST", "cloudfront", &self.region, &request_uri);
let mut params = Params::new();
params.put_key("WithTags");
request.set_params(params);
let mut writer = EventWriter::new(Vec::new());
DistributionConfigWithTagsSerializer::serialize(
&mut writer,
"DistributionConfigWithTags",
&input.distribution_config_with_tags,
);
request.set_payload(Some(writer.into_inner()));
let mut response = self
.sign_and_dispatch(request, CreateDistributionWithTagsError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
CreateDistributionWithTagsResultDeserializer::deserialize(actual_tag_name, stack)
})
.await?;
let mut result = result;
result.e_tag = response.headers.remove("ETag");
result.location = response.headers.remove("Location");
Ok(result)
}
#[allow(unused_variables, warnings)]
async fn create_field_level_encryption_config(
&self,
input: CreateFieldLevelEncryptionConfigRequest,
) -> Result<
CreateFieldLevelEncryptionConfigResult,
RusotoError<CreateFieldLevelEncryptionConfigError>,
> {
let request_uri = "/2019-03-26/field-level-encryption";
let mut request = SignedRequest::new("POST", "cloudfront", &self.region, &request_uri);
let mut writer = EventWriter::new(Vec::new());
FieldLevelEncryptionConfigSerializer::serialize(
&mut writer,
"FieldLevelEncryptionConfig",
&input.field_level_encryption_config,
);
request.set_payload(Some(writer.into_inner()));
let mut response = self
.sign_and_dispatch(
request,
CreateFieldLevelEncryptionConfigError::from_response,
)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
CreateFieldLevelEncryptionConfigResultDeserializer::deserialize(actual_tag_name, stack)
})
.await?;
let mut result = result;
result.e_tag = response.headers.remove("ETag");
result.location = response.headers.remove("Location");
Ok(result)
}
#[allow(unused_variables, warnings)]
async fn create_field_level_encryption_profile(
&self,
input: CreateFieldLevelEncryptionProfileRequest,
) -> Result<
CreateFieldLevelEncryptionProfileResult,
RusotoError<CreateFieldLevelEncryptionProfileError>,
> {
let request_uri = "/2019-03-26/field-level-encryption-profile";
let mut request = SignedRequest::new("POST", "cloudfront", &self.region, &request_uri);
let mut writer = EventWriter::new(Vec::new());
FieldLevelEncryptionProfileConfigSerializer::serialize(
&mut writer,
"FieldLevelEncryptionProfileConfig",
&input.field_level_encryption_profile_config,
);
request.set_payload(Some(writer.into_inner()));
let mut response = self
.sign_and_dispatch(
request,
CreateFieldLevelEncryptionProfileError::from_response,
)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
CreateFieldLevelEncryptionProfileResultDeserializer::deserialize(actual_tag_name, stack)
})
.await?;
let mut result = result;
result.e_tag = response.headers.remove("ETag");
result.location = response.headers.remove("Location");
Ok(result)
}
#[allow(unused_variables, warnings)]
async fn create_invalidation(
&self,
input: CreateInvalidationRequest,
) -> Result<CreateInvalidationResult, RusotoError<CreateInvalidationError>> {
let request_uri = format!(
"/2019-03-26/distribution/{distribution_id}/invalidation",
distribution_id = input.distribution_id
);
let mut request = SignedRequest::new("POST", "cloudfront", &self.region, &request_uri);
let mut writer = EventWriter::new(Vec::new());
InvalidationBatchSerializer::serialize(
&mut writer,
"InvalidationBatch",
&input.invalidation_batch,
);
request.set_payload(Some(writer.into_inner()));
let mut response = self
.sign_and_dispatch(request, CreateInvalidationError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
CreateInvalidationResultDeserializer::deserialize(actual_tag_name, stack)
})
.await?;
let mut result = result;
result.location = response.headers.remove("Location");
Ok(result)
}
#[allow(unused_variables, warnings)]
async fn create_public_key(
&self,
input: CreatePublicKeyRequest,
) -> Result<CreatePublicKeyResult, RusotoError<CreatePublicKeyError>> {
let request_uri = "/2019-03-26/public-key";
let mut request = SignedRequest::new("POST", "cloudfront", &self.region, &request_uri);
let mut writer = EventWriter::new(Vec::new());
PublicKeyConfigSerializer::serialize(
&mut writer,
"PublicKeyConfig",
&input.public_key_config,
);
request.set_payload(Some(writer.into_inner()));
let mut response = self
.sign_and_dispatch(request, CreatePublicKeyError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
CreatePublicKeyResultDeserializer::deserialize(actual_tag_name, stack)
})
.await?;
let mut result = result;
result.e_tag = response.headers.remove("ETag");
result.location = response.headers.remove("Location");
Ok(result)
}
#[allow(unused_variables, warnings)]
async fn create_streaming_distribution(
&self,
input: CreateStreamingDistributionRequest,
) -> Result<CreateStreamingDistributionResult, RusotoError<CreateStreamingDistributionError>>
{
let request_uri = "/2019-03-26/streaming-distribution";
let mut request = SignedRequest::new("POST", "cloudfront", &self.region, &request_uri);
let mut writer = EventWriter::new(Vec::new());
StreamingDistributionConfigSerializer::serialize(
&mut writer,
"StreamingDistributionConfig",
&input.streaming_distribution_config,
);
request.set_payload(Some(writer.into_inner()));
let mut response = self
.sign_and_dispatch(request, CreateStreamingDistributionError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
CreateStreamingDistributionResultDeserializer::deserialize(actual_tag_name, stack)
})
.await?;
let mut result = result;
result.e_tag = response.headers.remove("ETag");
result.location = response.headers.remove("Location");
Ok(result)
}
#[allow(unused_variables, warnings)]
async fn create_streaming_distribution_with_tags(
&self,
input: CreateStreamingDistributionWithTagsRequest,
) -> Result<
CreateStreamingDistributionWithTagsResult,
RusotoError<CreateStreamingDistributionWithTagsError>,
> {
let request_uri = "/2019-03-26/streaming-distribution";
let mut request = SignedRequest::new("POST", "cloudfront", &self.region, &request_uri);
let mut params = Params::new();
params.put_key("WithTags");
request.set_params(params);
let mut writer = EventWriter::new(Vec::new());
StreamingDistributionConfigWithTagsSerializer::serialize(
&mut writer,
"StreamingDistributionConfigWithTags",
&input.streaming_distribution_config_with_tags,
);
request.set_payload(Some(writer.into_inner()));
let mut response = self
.sign_and_dispatch(
request,
CreateStreamingDistributionWithTagsError::from_response,
)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
CreateStreamingDistributionWithTagsResultDeserializer::deserialize(
actual_tag_name,
stack,
)
})
.await?;
let mut result = result;
result.e_tag = response.headers.remove("ETag");
result.location = response.headers.remove("Location");
Ok(result)
}
#[allow(unused_variables, warnings)]
async fn delete_cloud_front_origin_access_identity(
&self,
input: DeleteCloudFrontOriginAccessIdentityRequest,
) -> Result<(), RusotoError<DeleteCloudFrontOriginAccessIdentityError>> {
let request_uri = format!(
"/2019-03-26/origin-access-identity/cloudfront/{id}",
id = input.id
);
let mut request = SignedRequest::new("DELETE", "cloudfront", &self.region, &request_uri);
request.add_optional_header("If-Match", input.if_match.as_ref());
let mut response = self
.sign_and_dispatch(
request,
DeleteCloudFrontOriginAccessIdentityError::from_response,
)
.await?;
std::mem::drop(response);
Ok(())
}
#[allow(unused_variables, warnings)]
async fn delete_distribution(
&self,
input: DeleteDistributionRequest,
) -> Result<(), RusotoError<DeleteDistributionError>> {
let request_uri = format!("/2019-03-26/distribution/{id}", id = input.id);
let mut request = SignedRequest::new("DELETE", "cloudfront", &self.region, &request_uri);
request.add_optional_header("If-Match", input.if_match.as_ref());
let mut response = self
.sign_and_dispatch(request, DeleteDistributionError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
#[allow(unused_variables, warnings)]
async fn delete_field_level_encryption_config(
&self,
input: DeleteFieldLevelEncryptionConfigRequest,
) -> Result<(), RusotoError<DeleteFieldLevelEncryptionConfigError>> {
let request_uri = format!("/2019-03-26/field-level-encryption/{id}", id = input.id);
let mut request = SignedRequest::new("DELETE", "cloudfront", &self.region, &request_uri);
request.add_optional_header("If-Match", input.if_match.as_ref());
let mut response = self
.sign_and_dispatch(
request,
DeleteFieldLevelEncryptionConfigError::from_response,
)
.await?;
std::mem::drop(response);
Ok(())
}
#[allow(unused_variables, warnings)]
async fn delete_field_level_encryption_profile(
&self,
input: DeleteFieldLevelEncryptionProfileRequest,
) -> Result<(), RusotoError<DeleteFieldLevelEncryptionProfileError>> {
let request_uri = format!(
"/2019-03-26/field-level-encryption-profile/{id}",
id = input.id
);
let mut request = SignedRequest::new("DELETE", "cloudfront", &self.region, &request_uri);
request.add_optional_header("If-Match", input.if_match.as_ref());
let mut response = self
.sign_and_dispatch(
request,
DeleteFieldLevelEncryptionProfileError::from_response,
)
.await?;
std::mem::drop(response);
Ok(())
}
#[allow(unused_variables, warnings)]
async fn delete_public_key(
&self,
input: DeletePublicKeyRequest,
) -> Result<(), RusotoError<DeletePublicKeyError>> {
let request_uri = format!("/2019-03-26/public-key/{id}", id = input.id);
let mut request = SignedRequest::new("DELETE", "cloudfront", &self.region, &request_uri);
request.add_optional_header("If-Match", input.if_match.as_ref());
let mut response = self
.sign_and_dispatch(request, DeletePublicKeyError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
#[allow(unused_variables, warnings)]
async fn delete_streaming_distribution(
&self,
input: DeleteStreamingDistributionRequest,
) -> Result<(), RusotoError<DeleteStreamingDistributionError>> {
let request_uri = format!("/2019-03-26/streaming-distribution/{id}", id = input.id);
let mut request = SignedRequest::new("DELETE", "cloudfront", &self.region, &request_uri);
request.add_optional_header("If-Match", input.if_match.as_ref());
let mut response = self
.sign_and_dispatch(request, DeleteStreamingDistributionError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
#[allow(unused_variables, warnings)]
async fn get_cloud_front_origin_access_identity(
&self,
input: GetCloudFrontOriginAccessIdentityRequest,
) -> Result<
GetCloudFrontOriginAccessIdentityResult,
RusotoError<GetCloudFrontOriginAccessIdentityError>,
> {
let request_uri = format!(
"/2019-03-26/origin-access-identity/cloudfront/{id}",
id = input.id
);
let mut request = SignedRequest::new("GET", "cloudfront", &self.region, &request_uri);
let mut response = self
.sign_and_dispatch(
request,
GetCloudFrontOriginAccessIdentityError::from_response,
)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
GetCloudFrontOriginAccessIdentityResultDeserializer::deserialize(actual_tag_name, stack)
})
.await?;
let mut result = result;
result.e_tag = response.headers.remove("ETag");
Ok(result)
}
#[allow(unused_variables, warnings)]
async fn get_cloud_front_origin_access_identity_config(
&self,
input: GetCloudFrontOriginAccessIdentityConfigRequest,
) -> Result<
GetCloudFrontOriginAccessIdentityConfigResult,
RusotoError<GetCloudFrontOriginAccessIdentityConfigError>,
> {
let request_uri = format!(
"/2019-03-26/origin-access-identity/cloudfront/{id}/config",
id = input.id
);
let mut request = SignedRequest::new("GET", "cloudfront", &self.region, &request_uri);
let mut response = self
.sign_and_dispatch(
request,
GetCloudFrontOriginAccessIdentityConfigError::from_response,
)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
GetCloudFrontOriginAccessIdentityConfigResultDeserializer::deserialize(
actual_tag_name,
stack,
)
})
.await?;
let mut result = result;
result.e_tag = response.headers.remove("ETag");
Ok(result)
}
#[allow(unused_variables, warnings)]
async fn get_distribution(
&self,
input: GetDistributionRequest,
) -> Result<GetDistributionResult, RusotoError<GetDistributionError>> {
let request_uri = format!("/2019-03-26/distribution/{id}", id = input.id);
let mut request = SignedRequest::new("GET", "cloudfront", &self.region, &request_uri);
let mut response = self
.sign_and_dispatch(request, GetDistributionError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
GetDistributionResultDeserializer::deserialize(actual_tag_name, stack)
})
.await?;
let mut result = result;
result.e_tag = response.headers.remove("ETag");
Ok(result)
}
#[allow(unused_variables, warnings)]
async fn get_distribution_config(
&self,
input: GetDistributionConfigRequest,
) -> Result<GetDistributionConfigResult, RusotoError<GetDistributionConfigError>> {
let request_uri = format!("/2019-03-26/distribution/{id}/config", id = input.id);
let mut request = SignedRequest::new("GET", "cloudfront", &self.region, &request_uri);
let mut response = self
.sign_and_dispatch(request, GetDistributionConfigError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
GetDistributionConfigResultDeserializer::deserialize(actual_tag_name, stack)
})
.await?;
let mut result = result;
result.e_tag = response.headers.remove("ETag");
Ok(result)
}
#[allow(unused_variables, warnings)]
async fn get_field_level_encryption(
&self,
input: GetFieldLevelEncryptionRequest,
) -> Result<GetFieldLevelEncryptionResult, RusotoError<GetFieldLevelEncryptionError>> {
let request_uri = format!("/2019-03-26/field-level-encryption/{id}", id = input.id);
let mut request = SignedRequest::new("GET", "cloudfront", &self.region, &request_uri);
let mut response = self
.sign_and_dispatch(request, GetFieldLevelEncryptionError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
GetFieldLevelEncryptionResultDeserializer::deserialize(actual_tag_name, stack)
})
.await?;
let mut result = result;
result.e_tag = response.headers.remove("ETag");
Ok(result)
}
#[allow(unused_variables, warnings)]
async fn get_field_level_encryption_config(
&self,
input: GetFieldLevelEncryptionConfigRequest,
) -> Result<GetFieldLevelEncryptionConfigResult, RusotoError<GetFieldLevelEncryptionConfigError>>
{
let request_uri = format!(
"/2019-03-26/field-level-encryption/{id}/config",
id = input.id
);
let mut request = SignedRequest::new("GET", "cloudfront", &self.region, &request_uri);
let mut response = self
.sign_and_dispatch(request, GetFieldLevelEncryptionConfigError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
GetFieldLevelEncryptionConfigResultDeserializer::deserialize(actual_tag_name, stack)
})
.await?;
let mut result = result;
result.e_tag = response.headers.remove("ETag");
Ok(result)
}
#[allow(unused_variables, warnings)]
async fn get_field_level_encryption_profile(
&self,
input: GetFieldLevelEncryptionProfileRequest,
) -> Result<
GetFieldLevelEncryptionProfileResult,
RusotoError<GetFieldLevelEncryptionProfileError>,
> {
let request_uri = format!(
"/2019-03-26/field-level-encryption-profile/{id}",
id = input.id
);
let mut request = SignedRequest::new("GET", "cloudfront", &self.region, &request_uri);
let mut response = self
.sign_and_dispatch(request, GetFieldLevelEncryptionProfileError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
GetFieldLevelEncryptionProfileResultDeserializer::deserialize(actual_tag_name, stack)
})
.await?;
let mut result = result;
result.e_tag = response.headers.remove("ETag");
Ok(result)
}
#[allow(unused_variables, warnings)]
async fn get_field_level_encryption_profile_config(
&self,
input: GetFieldLevelEncryptionProfileConfigRequest,
) -> Result<
GetFieldLevelEncryptionProfileConfigResult,
RusotoError<GetFieldLevelEncryptionProfileConfigError>,
> {
let request_uri = format!(
"/2019-03-26/field-level-encryption-profile/{id}/config",
id = input.id
);
let mut request = SignedRequest::new("GET", "cloudfront", &self.region, &request_uri);
let mut response = self
.sign_and_dispatch(
request,
GetFieldLevelEncryptionProfileConfigError::from_response,
)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
GetFieldLevelEncryptionProfileConfigResultDeserializer::deserialize(
actual_tag_name,
stack,
)
})
.await?;
let mut result = result;
result.e_tag = response.headers.remove("ETag");
Ok(result)
}
#[allow(unused_variables, warnings)]
async fn get_invalidation(
&self,
input: GetInvalidationRequest,
) -> Result<GetInvalidationResult, RusotoError<GetInvalidationError>> {
let request_uri = format!(
"/2019-03-26/distribution/{distribution_id}/invalidation/{id}",
distribution_id = input.distribution_id,
id = input.id
);
let mut request = SignedRequest::new("GET", "cloudfront", &self.region, &request_uri);
let mut response = self
.sign_and_dispatch(request, GetInvalidationError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
GetInvalidationResultDeserializer::deserialize(actual_tag_name, stack)
})
.await?;
let mut result = result;
Ok(result)
}
#[allow(unused_variables, warnings)]
async fn get_public_key(
&self,
input: GetPublicKeyRequest,
) -> Result<GetPublicKeyResult, RusotoError<GetPublicKeyError>> {
let request_uri = format!("/2019-03-26/public-key/{id}", id = input.id);
let mut request = SignedRequest::new("GET", "cloudfront", &self.region, &request_uri);
let mut response = self
.sign_and_dispatch(request, GetPublicKeyError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
GetPublicKeyResultDeserializer::deserialize(actual_tag_name, stack)
})
.await?;
let mut result = result;
result.e_tag = response.headers.remove("ETag");
Ok(result)
}
#[allow(unused_variables, warnings)]
async fn get_public_key_config(
&self,
input: GetPublicKeyConfigRequest,
) -> Result<GetPublicKeyConfigResult, RusotoError<GetPublicKeyConfigError>> {
let request_uri = format!("/2019-03-26/public-key/{id}/config", id = input.id);
let mut request = SignedRequest::new("GET", "cloudfront", &self.region, &request_uri);
let mut response = self
.sign_and_dispatch(request, GetPublicKeyConfigError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
GetPublicKeyConfigResultDeserializer::deserialize(actual_tag_name, stack)
})
.await?;
let mut result = result;
result.e_tag = response.headers.remove("ETag");
Ok(result)
}
#[allow(unused_variables, warnings)]
async fn get_streaming_distribution(
&self,
input: GetStreamingDistributionRequest,
) -> Result<GetStreamingDistributionResult, RusotoError<GetStreamingDistributionError>> {
let request_uri = format!("/2019-03-26/streaming-distribution/{id}", id = input.id);
let mut request = SignedRequest::new("GET", "cloudfront", &self.region, &request_uri);
let mut response = self
.sign_and_dispatch(request, GetStreamingDistributionError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
GetStreamingDistributionResultDeserializer::deserialize(actual_tag_name, stack)
})
.await?;
let mut result = result;
result.e_tag = response.headers.remove("ETag");
Ok(result)
}
#[allow(unused_variables, warnings)]
async fn get_streaming_distribution_config(
&self,
input: GetStreamingDistributionConfigRequest,
) -> Result<
GetStreamingDistributionConfigResult,
RusotoError<GetStreamingDistributionConfigError>,
> {
let request_uri = format!(
"/2019-03-26/streaming-distribution/{id}/config",
id = input.id
);
let mut request = SignedRequest::new("GET", "cloudfront", &self.region, &request_uri);
let mut response = self
.sign_and_dispatch(request, GetStreamingDistributionConfigError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
GetStreamingDistributionConfigResultDeserializer::deserialize(actual_tag_name, stack)
})
.await?;
let mut result = result;
result.e_tag = response.headers.remove("ETag");
Ok(result)
}
#[allow(unused_variables, warnings)]
async fn list_cloud_front_origin_access_identities(
&self,
input: ListCloudFrontOriginAccessIdentitiesRequest,
) -> Result<
ListCloudFrontOriginAccessIdentitiesResult,
RusotoError<ListCloudFrontOriginAccessIdentitiesError>,
> {
let request_uri = "/2019-03-26/origin-access-identity/cloudfront";
let mut request = SignedRequest::new("GET", "cloudfront", &self.region, &request_uri);
let mut params = Params::new();
if let Some(ref x) = input.marker {
params.put("Marker", x);
}
if let Some(ref x) = input.max_items {
params.put("MaxItems", x);
}
request.set_params(params);
let mut response = self
.sign_and_dispatch(
request,
ListCloudFrontOriginAccessIdentitiesError::from_response,
)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
ListCloudFrontOriginAccessIdentitiesResultDeserializer::deserialize(
actual_tag_name,
stack,
)
})
.await?;
let mut result = result;
Ok(result)
}
#[allow(unused_variables, warnings)]
async fn list_distributions(
&self,
input: ListDistributionsRequest,
) -> Result<ListDistributionsResult, RusotoError<ListDistributionsError>> {
let request_uri = "/2019-03-26/distribution";
let mut request = SignedRequest::new("GET", "cloudfront", &self.region, &request_uri);
let mut params = Params::new();
if let Some(ref x) = input.marker {
params.put("Marker", x);
}
if let Some(ref x) = input.max_items {
params.put("MaxItems", x);
}
request.set_params(params);
let mut response = self
.sign_and_dispatch(request, ListDistributionsError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
ListDistributionsResultDeserializer::deserialize(actual_tag_name, stack)
})
.await?;
let mut result = result;
Ok(result)
}
#[allow(unused_variables, warnings)]
async fn list_distributions_by_web_acl_id(
&self,
input: ListDistributionsByWebACLIdRequest,
) -> Result<ListDistributionsByWebACLIdResult, RusotoError<ListDistributionsByWebACLIdError>>
{
let request_uri = format!(
"/2019-03-26/distributionsByWebACLId/{web_acl_id}",
web_acl_id = input.web_acl_id
);
let mut request = SignedRequest::new("GET", "cloudfront", &self.region, &request_uri);
let mut params = Params::new();
if let Some(ref x) = input.marker {
params.put("Marker", x);
}
if let Some(ref x) = input.max_items {
params.put("MaxItems", x);
}
request.set_params(params);
let mut response = self
.sign_and_dispatch(request, ListDistributionsByWebACLIdError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
ListDistributionsByWebACLIdResultDeserializer::deserialize(actual_tag_name, stack)
})
.await?;
let mut result = result;
Ok(result)
}
#[allow(unused_variables, warnings)]
async fn list_field_level_encryption_configs(
&self,
input: ListFieldLevelEncryptionConfigsRequest,
) -> Result<
ListFieldLevelEncryptionConfigsResult,
RusotoError<ListFieldLevelEncryptionConfigsError>,
> {
let request_uri = "/2019-03-26/field-level-encryption";
let mut request = SignedRequest::new("GET", "cloudfront", &self.region, &request_uri);
let mut params = Params::new();
if let Some(ref x) = input.marker {
params.put("Marker", x);
}
if let Some(ref x) = input.max_items {
params.put("MaxItems", x);
}
request.set_params(params);
let mut response = self
.sign_and_dispatch(request, ListFieldLevelEncryptionConfigsError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
ListFieldLevelEncryptionConfigsResultDeserializer::deserialize(actual_tag_name, stack)
})
.await?;
let mut result = result;
Ok(result)
}
#[allow(unused_variables, warnings)]
async fn list_field_level_encryption_profiles(
&self,
input: ListFieldLevelEncryptionProfilesRequest,
) -> Result<
ListFieldLevelEncryptionProfilesResult,
RusotoError<ListFieldLevelEncryptionProfilesError>,
> {
let request_uri = "/2019-03-26/field-level-encryption-profile";
let mut request = SignedRequest::new("GET", "cloudfront", &self.region, &request_uri);
let mut params = Params::new();
if let Some(ref x) = input.marker {
params.put("Marker", x);
}
if let Some(ref x) = input.max_items {
params.put("MaxItems", x);
}
request.set_params(params);
let mut response = self
.sign_and_dispatch(
request,
ListFieldLevelEncryptionProfilesError::from_response,
)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
ListFieldLevelEncryptionProfilesResultDeserializer::deserialize(actual_tag_name, stack)
})
.await?;
let mut result = result;
Ok(result)
}
#[allow(unused_variables, warnings)]
async fn list_invalidations(
&self,
input: ListInvalidationsRequest,
) -> Result<ListInvalidationsResult, RusotoError<ListInvalidationsError>> {
let request_uri = format!(
"/2019-03-26/distribution/{distribution_id}/invalidation",
distribution_id = input.distribution_id
);
let mut request = SignedRequest::new("GET", "cloudfront", &self.region, &request_uri);
let mut params = Params::new();
if let Some(ref x) = input.marker {
params.put("Marker", x);
}
if let Some(ref x) = input.max_items {
params.put("MaxItems", x);
}
request.set_params(params);
let mut response = self
.sign_and_dispatch(request, ListInvalidationsError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
ListInvalidationsResultDeserializer::deserialize(actual_tag_name, stack)
})
.await?;
let mut result = result;
Ok(result)
}
#[allow(unused_variables, warnings)]
async fn list_public_keys(
&self,
input: ListPublicKeysRequest,
) -> Result<ListPublicKeysResult, RusotoError<ListPublicKeysError>> {
let request_uri = "/2019-03-26/public-key";
let mut request = SignedRequest::new("GET", "cloudfront", &self.region, &request_uri);
let mut params = Params::new();
if let Some(ref x) = input.marker {
params.put("Marker", x);
}
if let Some(ref x) = input.max_items {
params.put("MaxItems", x);
}
request.set_params(params);
let mut response = self
.sign_and_dispatch(request, ListPublicKeysError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
ListPublicKeysResultDeserializer::deserialize(actual_tag_name, stack)
})
.await?;
let mut result = result;
Ok(result)
}
#[allow(unused_variables, warnings)]
async fn list_streaming_distributions(
&self,
input: ListStreamingDistributionsRequest,
) -> Result<ListStreamingDistributionsResult, RusotoError<ListStreamingDistributionsError>>
{
let request_uri = "/2019-03-26/streaming-distribution";
let mut request = SignedRequest::new("GET", "cloudfront", &self.region, &request_uri);
let mut params = Params::new();
if let Some(ref x) = input.marker {
params.put("Marker", x);
}
if let Some(ref x) = input.max_items {
params.put("MaxItems", x);
}
request.set_params(params);
let mut response = self
.sign_and_dispatch(request, ListStreamingDistributionsError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
ListStreamingDistributionsResultDeserializer::deserialize(actual_tag_name, stack)
})
.await?;
let mut result = result;
Ok(result)
}
#[allow(unused_variables, warnings)]
async fn list_tags_for_resource(
&self,
input: ListTagsForResourceRequest,
) -> Result<ListTagsForResourceResult, RusotoError<ListTagsForResourceError>> {
let request_uri = "/2019-03-26/tagging";
let mut request = SignedRequest::new("GET", "cloudfront", &self.region, &request_uri);
let mut params = Params::new();
params.put("Resource", &input.resource);
request.set_params(params);
let mut 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| {
ListTagsForResourceResultDeserializer::deserialize(actual_tag_name, stack)
})
.await?;
let mut result = result;
Ok(result)
}
#[allow(unused_variables, warnings)]
async fn tag_resource(
&self,
input: TagResourceRequest,
) -> Result<(), RusotoError<TagResourceError>> {
let request_uri = "/2019-03-26/tagging";
let mut request = SignedRequest::new("POST", "cloudfront", &self.region, &request_uri);
let mut params = Params::new();
params.put("Resource", &input.resource);
params.put("Operation", "Tag");
request.set_params(params);
let mut writer = EventWriter::new(Vec::new());
TagsSerializer::serialize(&mut writer, "Tags", &input.tags);
request.set_payload(Some(writer.into_inner()));
let mut response = self
.sign_and_dispatch(request, TagResourceError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
#[allow(unused_variables, warnings)]
async fn untag_resource(
&self,
input: UntagResourceRequest,
) -> Result<(), RusotoError<UntagResourceError>> {
let request_uri = "/2019-03-26/tagging";
let mut request = SignedRequest::new("POST", "cloudfront", &self.region, &request_uri);
let mut params = Params::new();
params.put("Resource", &input.resource);
params.put("Operation", "Untag");
request.set_params(params);
let mut writer = EventWriter::new(Vec::new());
TagKeysSerializer::serialize(&mut writer, "TagKeys", &input.tag_keys);
request.set_payload(Some(writer.into_inner()));
let mut response = self
.sign_and_dispatch(request, UntagResourceError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
#[allow(unused_variables, warnings)]
async fn update_cloud_front_origin_access_identity(
&self,
input: UpdateCloudFrontOriginAccessIdentityRequest,
) -> Result<
UpdateCloudFrontOriginAccessIdentityResult,
RusotoError<UpdateCloudFrontOriginAccessIdentityError>,
> {
let request_uri = format!(
"/2019-03-26/origin-access-identity/cloudfront/{id}/config",
id = input.id
);
let mut request = SignedRequest::new("PUT", "cloudfront", &self.region, &request_uri);
request.add_optional_header("If-Match", input.if_match.as_ref());
let mut writer = EventWriter::new(Vec::new());
CloudFrontOriginAccessIdentityConfigSerializer::serialize(
&mut writer,
"CloudFrontOriginAccessIdentityConfig",
&input.cloud_front_origin_access_identity_config,
);
request.set_payload(Some(writer.into_inner()));
let mut response = self
.sign_and_dispatch(
request,
UpdateCloudFrontOriginAccessIdentityError::from_response,
)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
UpdateCloudFrontOriginAccessIdentityResultDeserializer::deserialize(
actual_tag_name,
stack,
)
})
.await?;
let mut result = result;
result.e_tag = response.headers.remove("ETag");
Ok(result)
}
#[allow(unused_variables, warnings)]
async fn update_distribution(
&self,
input: UpdateDistributionRequest,
) -> Result<UpdateDistributionResult, RusotoError<UpdateDistributionError>> {
let request_uri = format!("/2019-03-26/distribution/{id}/config", id = input.id);
let mut request = SignedRequest::new("PUT", "cloudfront", &self.region, &request_uri);
request.add_optional_header("If-Match", input.if_match.as_ref());
let mut writer = EventWriter::new(Vec::new());
DistributionConfigSerializer::serialize(
&mut writer,
"DistributionConfig",
&input.distribution_config,
);
request.set_payload(Some(writer.into_inner()));
let mut response = self
.sign_and_dispatch(request, UpdateDistributionError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
UpdateDistributionResultDeserializer::deserialize(actual_tag_name, stack)
})
.await?;
let mut result = result;
result.e_tag = response.headers.remove("ETag");
Ok(result)
}
#[allow(unused_variables, warnings)]
async fn update_field_level_encryption_config(
&self,
input: UpdateFieldLevelEncryptionConfigRequest,
) -> Result<
UpdateFieldLevelEncryptionConfigResult,
RusotoError<UpdateFieldLevelEncryptionConfigError>,
> {
let request_uri = format!(
"/2019-03-26/field-level-encryption/{id}/config",
id = input.id
);
let mut request = SignedRequest::new("PUT", "cloudfront", &self.region, &request_uri);
request.add_optional_header("If-Match", input.if_match.as_ref());
let mut writer = EventWriter::new(Vec::new());
FieldLevelEncryptionConfigSerializer::serialize(
&mut writer,
"FieldLevelEncryptionConfig",
&input.field_level_encryption_config,
);
request.set_payload(Some(writer.into_inner()));
let mut response = self
.sign_and_dispatch(
request,
UpdateFieldLevelEncryptionConfigError::from_response,
)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
UpdateFieldLevelEncryptionConfigResultDeserializer::deserialize(actual_tag_name, stack)
})
.await?;
let mut result = result;
result.e_tag = response.headers.remove("ETag");
Ok(result)
}
#[allow(unused_variables, warnings)]
async fn update_field_level_encryption_profile(
&self,
input: UpdateFieldLevelEncryptionProfileRequest,
) -> Result<
UpdateFieldLevelEncryptionProfileResult,
RusotoError<UpdateFieldLevelEncryptionProfileError>,
> {
let request_uri = format!(
"/2019-03-26/field-level-encryption-profile/{id}/config",
id = input.id
);
let mut request = SignedRequest::new("PUT", "cloudfront", &self.region, &request_uri);
request.add_optional_header("If-Match", input.if_match.as_ref());
let mut writer = EventWriter::new(Vec::new());
FieldLevelEncryptionProfileConfigSerializer::serialize(
&mut writer,
"FieldLevelEncryptionProfileConfig",
&input.field_level_encryption_profile_config,
);
request.set_payload(Some(writer.into_inner()));
let mut response = self
.sign_and_dispatch(
request,
UpdateFieldLevelEncryptionProfileError::from_response,
)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
UpdateFieldLevelEncryptionProfileResultDeserializer::deserialize(actual_tag_name, stack)
})
.await?;
let mut result = result;
result.e_tag = response.headers.remove("ETag");
Ok(result)
}
#[allow(unused_variables, warnings)]
async fn update_public_key(
&self,
input: UpdatePublicKeyRequest,
) -> Result<UpdatePublicKeyResult, RusotoError<UpdatePublicKeyError>> {
let request_uri = format!("/2019-03-26/public-key/{id}/config", id = input.id);
let mut request = SignedRequest::new("PUT", "cloudfront", &self.region, &request_uri);
request.add_optional_header("If-Match", input.if_match.as_ref());
let mut writer = EventWriter::new(Vec::new());
PublicKeyConfigSerializer::serialize(
&mut writer,
"PublicKeyConfig",
&input.public_key_config,
);
request.set_payload(Some(writer.into_inner()));
let mut response = self
.sign_and_dispatch(request, UpdatePublicKeyError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
UpdatePublicKeyResultDeserializer::deserialize(actual_tag_name, stack)
})
.await?;
let mut result = result;
result.e_tag = response.headers.remove("ETag");
Ok(result)
}
#[allow(unused_variables, warnings)]
async fn update_streaming_distribution(
&self,
input: UpdateStreamingDistributionRequest,
) -> Result<UpdateStreamingDistributionResult, RusotoError<UpdateStreamingDistributionError>>
{
let request_uri = format!(
"/2019-03-26/streaming-distribution/{id}/config",
id = input.id
);
let mut request = SignedRequest::new("PUT", "cloudfront", &self.region, &request_uri);
request.add_optional_header("If-Match", input.if_match.as_ref());
let mut writer = EventWriter::new(Vec::new());
StreamingDistributionConfigSerializer::serialize(
&mut writer,
"StreamingDistributionConfig",
&input.streaming_distribution_config,
);
request.set_payload(Some(writer.into_inner()));
let mut response = self
.sign_and_dispatch(request, UpdateStreamingDistributionError::from_response)
.await?;
let mut response = response;
let result = xml_util::parse_response(&mut response, |actual_tag_name, stack| {
UpdateStreamingDistributionResultDeserializer::deserialize(actual_tag_name, stack)
})
.await?;
let mut result = result;
result.e_tag = response.headers.remove("ETag");
Ok(result)
}
}
#[cfg(test)]
mod protocol_tests {
extern crate rusoto_mock;
use self::rusoto_mock::*;
use super::*;
use rusoto_core::Region as rusoto_region;
#[tokio::test]
async fn test_parse_valid_cloudfront_get_cloud_front_origin_access_identity() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"cloudfront-get-cloud-front-origin-access-identity.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client =
CloudFrontClient::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = GetCloudFrontOriginAccessIdentityRequest::default();
let result = client.get_cloud_front_origin_access_identity(request).await;
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[tokio::test]
async fn test_parse_valid_cloudfront_get_distribution() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"cloudfront-get-distribution.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client =
CloudFrontClient::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = GetDistributionRequest::default();
let result = client.get_distribution(request).await;
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[tokio::test]
async fn test_parse_valid_cloudfront_get_invalidation() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"cloudfront-get-invalidation.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client =
CloudFrontClient::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = GetInvalidationRequest::default();
let result = client.get_invalidation(request).await;
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[tokio::test]
async fn test_parse_valid_cloudfront_get_streaming_distribution() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"cloudfront-get-streaming-distribution.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client =
CloudFrontClient::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = GetStreamingDistributionRequest::default();
let result = client.get_streaming_distribution(request).await;
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[tokio::test]
async fn test_parse_valid_cloudfront_list_cloud_front_origin_access_identities() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"cloudfront-list-cloud-front-origin-access-identities.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client =
CloudFrontClient::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = ListCloudFrontOriginAccessIdentitiesRequest::default();
let result = client
.list_cloud_front_origin_access_identities(request)
.await;
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[tokio::test]
async fn test_parse_valid_cloudfront_list_distributions() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"cloudfront-list-distributions.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client =
CloudFrontClient::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = ListDistributionsRequest::default();
let result = client.list_distributions(request).await;
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[tokio::test]
async fn test_parse_valid_cloudfront_list_invalidations() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"cloudfront-list-invalidations.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client =
CloudFrontClient::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = ListInvalidationsRequest::default();
let result = client.list_invalidations(request).await;
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[tokio::test]
async fn test_parse_valid_cloudfront_list_streaming_distributions() {
let mock_response = MockResponseReader::read_response(
"test_resources/generated/valid",
"cloudfront-list-streaming-distributions.xml",
);
let mock = MockRequestDispatcher::with_status(200).with_body(&mock_response);
let client =
CloudFrontClient::new_with(mock, MockCredentialsProvider, rusoto_region::UsEast1);
let request = ListStreamingDistributionsRequest::default();
let result = client.list_streaming_distributions(request).await;
assert!(result.is_ok(), "parse error: {:?}", result);
}
}