use std::error::Error;
use std::fmt;
use std::io;
#[allow(warnings)]
use futures::future;
use futures::Future;
use rusoto_core::region;
use rusoto_core::request::{BufferedHttpResponse, DispatchSignedRequest};
use rusoto_core::{Client, RusotoFuture};
use rusoto_core::credential::{CredentialsError, ProvideAwsCredentials};
use rusoto_core::request::HttpDispatchError;
use rusoto_core::param::{Params, ServiceParams};
use rusoto_core::signature::SignedRequest;
use rusoto_core::xmlerror::*;
use rusoto_core::xmlutil::{
characters, end_element, find_start_element, peek_at_name, skip_tree, start_element,
};
use rusoto_core::xmlutil::{Next, Peek, XmlParseError, XmlResponse};
use std::io::Write;
use std::str::FromStr;
use xml;
use xml::reader::ParserConfig;
use xml::reader::XmlEvent;
use xml::EventReader;
use xml::EventWriter;
enum DeserializerNext {
Close,
Skip,
Element(String),
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ActiveTrustedSigners {
pub enabled: bool,
pub items: Option<Vec<Signer>>,
pub quantity: i64,
}
struct ActiveTrustedSignersDeserializer;
impl ActiveTrustedSignersDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ActiveTrustedSigners, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = ActiveTrustedSigners::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"Enabled" => {
obj.enabled = BooleanDeserializer::deserialize("Enabled", stack)?;
}
"Items" => {
obj.items = match obj.items {
Some(ref mut existing) => {
existing
.extend(SignerListDeserializer::deserialize("Items", stack)?);
Some(existing.to_vec())
}
None => Some(SignerListDeserializer::deserialize("Items", stack)?),
};
}
"Quantity" => {
obj.quantity = IntegerDeserializer::deserialize("Quantity", stack)?;
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct AliasListDeserializer;
impl AliasListDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<String>, XmlParseError> {
let mut obj = vec![];
start_element(tag_name, stack)?;
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "CNAME" {
obj.push(StringDeserializer::deserialize("CNAME", stack)?);
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
end_element(tag_name, stack)?;
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
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(Default, Debug, Clone, PartialEq)]
pub struct Aliases {
pub items: Option<Vec<String>>,
pub quantity: i64,
}
struct AliasesDeserializer;
impl AliasesDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Aliases, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = Aliases::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"Items" => {
obj.items = match obj.items {
Some(ref mut existing) => {
existing
.extend(AliasListDeserializer::deserialize("Items", stack)?);
Some(existing.to_vec())
}
None => Some(AliasListDeserializer::deserialize("Items", stack)?),
};
}
"Quantity" => {
obj.quantity = IntegerDeserializer::deserialize("Quantity", stack)?;
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
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)?;
}
writer.write(xml::writer::XmlEvent::start_element("Quantity"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.quantity
)))?;
writer.write(xml::writer::XmlEvent::end_element())?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct AllowedMethods {
pub cached_methods: Option<CachedMethods>,
pub items: Vec<String>,
pub quantity: i64,
}
struct AllowedMethodsDeserializer;
impl AllowedMethodsDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<AllowedMethods, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = AllowedMethods::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"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),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
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)?;
writer.write(xml::writer::XmlEvent::start_element("Quantity"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.quantity
)))?;
writer.write(xml::writer::XmlEvent::end_element())?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
struct AwsAccountNumberListDeserializer;
impl AwsAccountNumberListDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<String>, XmlParseError> {
let mut obj = vec![];
start_element(tag_name, stack)?;
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "AwsAccountNumber" {
obj.push(StringDeserializer::deserialize("AwsAccountNumber", stack)?);
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
end_element(tag_name, stack)?;
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
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(())
}
}
struct BooleanDeserializer;
impl BooleanDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<bool, XmlParseError> {
start_element(tag_name, stack)?;
let obj = bool::from_str(characters(stack)?.as_ref()).unwrap();
end_element(tag_name, stack)?;
Ok(obj)
}
}
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,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.to_string()
)))?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CacheBehavior {
pub allowed_methods: Option<AllowedMethods>,
pub compress: Option<bool>,
pub default_ttl: Option<i64>,
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,
}
struct CacheBehaviorDeserializer;
impl CacheBehaviorDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CacheBehavior, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = CacheBehavior::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"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)?);
}
"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),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
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 {
writer.write(xml::writer::XmlEvent::start_element("Compress"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = value
)));
writer.write(xml::writer::XmlEvent::end_element())?;
}
if let Some(ref value) = obj.default_ttl {
writer.write(xml::writer::XmlEvent::start_element("DefaultTTL"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = value
)));
writer.write(xml::writer::XmlEvent::end_element())?;
}
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 {
writer.write(xml::writer::XmlEvent::start_element("MaxTTL"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = value
)));
writer.write(xml::writer::XmlEvent::end_element())?;
}
writer.write(xml::writer::XmlEvent::start_element("MinTTL"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.min_ttl
)))?;
writer.write(xml::writer::XmlEvent::end_element())?;
writer.write(xml::writer::XmlEvent::start_element("PathPattern"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.path_pattern
)))?;
writer.write(xml::writer::XmlEvent::end_element())?;
if let Some(ref value) = obj.smooth_streaming {
writer.write(xml::writer::XmlEvent::start_element("SmoothStreaming"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = value
)));
writer.write(xml::writer::XmlEvent::end_element())?;
}
writer.write(xml::writer::XmlEvent::start_element("TargetOriginId"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.target_origin_id
)))?;
writer.write(xml::writer::XmlEvent::end_element())?;
TrustedSignersSerializer::serialize(&mut writer, "TrustedSigners", &obj.trusted_signers)?;
writer.write(xml::writer::XmlEvent::start_element("ViewerProtocolPolicy"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.viewer_protocol_policy
)))?;
writer.write(xml::writer::XmlEvent::end_element())?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
struct CacheBehaviorListDeserializer;
impl CacheBehaviorListDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<CacheBehavior>, XmlParseError> {
let mut obj = vec![];
start_element(tag_name, stack)?;
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "CacheBehavior" {
obj.push(CacheBehaviorDeserializer::deserialize(
"CacheBehavior",
stack,
)?);
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
end_element(tag_name, stack)?;
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
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(Default, Debug, Clone, PartialEq)]
pub struct CacheBehaviors {
pub items: Option<Vec<CacheBehavior>>,
pub quantity: i64,
}
struct CacheBehaviorsDeserializer;
impl CacheBehaviorsDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CacheBehaviors, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = CacheBehaviors::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"Items" => {
obj.items = match obj.items {
Some(ref mut existing) => {
existing.extend(CacheBehaviorListDeserializer::deserialize(
"Items", stack,
)?);
Some(existing.to_vec())
}
None => {
Some(CacheBehaviorListDeserializer::deserialize("Items", stack)?)
}
};
}
"Quantity" => {
obj.quantity = IntegerDeserializer::deserialize("Quantity", stack)?;
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
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)?;
}
writer.write(xml::writer::XmlEvent::start_element("Quantity"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.quantity
)))?;
writer.write(xml::writer::XmlEvent::end_element())?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CachedMethods {
pub items: Vec<String>,
pub quantity: i64,
}
struct CachedMethodsDeserializer;
impl CachedMethodsDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CachedMethods, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = CachedMethods::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"Items" => {
obj.items
.extend(MethodsListDeserializer::deserialize("Items", stack)?);
}
"Quantity" => {
obj.quantity = IntegerDeserializer::deserialize("Quantity", stack)?;
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
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)?;
writer.write(xml::writer::XmlEvent::start_element("Quantity"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.quantity
)))?;
writer.write(xml::writer::XmlEvent::end_element())?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CloudFrontOriginAccessIdentity {
pub cloud_front_origin_access_identity_config: Option<CloudFrontOriginAccessIdentityConfig>,
pub id: String,
pub s3_canonical_user_id: String,
}
struct CloudFrontOriginAccessIdentityDeserializer;
impl CloudFrontOriginAccessIdentityDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CloudFrontOriginAccessIdentity, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = CloudFrontOriginAccessIdentity::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"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),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CloudFrontOriginAccessIdentityConfig {
pub caller_reference: String,
pub comment: String,
}
struct CloudFrontOriginAccessIdentityConfigDeserializer;
impl CloudFrontOriginAccessIdentityConfigDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CloudFrontOriginAccessIdentityConfig, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = CloudFrontOriginAccessIdentityConfig::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"CallerReference" => {
obj.caller_reference =
StringDeserializer::deserialize("CallerReference", stack)?;
}
"Comment" => {
obj.comment = StringDeserializer::deserialize("Comment", stack)?;
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
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))?;
writer.write(xml::writer::XmlEvent::start_element("CallerReference"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.caller_reference
)))?;
writer.write(xml::writer::XmlEvent::end_element())?;
writer.write(xml::writer::XmlEvent::start_element("Comment"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.comment
)))?;
writer.write(xml::writer::XmlEvent::end_element())?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[derive(Default, Debug, Clone, PartialEq)]
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,
}
struct CloudFrontOriginAccessIdentityListDeserializer;
impl CloudFrontOriginAccessIdentityListDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CloudFrontOriginAccessIdentityList, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = CloudFrontOriginAccessIdentityList::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
match &name[..] {
"IsTruncated" => {
obj.is_truncated =
BooleanDeserializer::deserialize("IsTruncated", stack)?;
}
"Items" => {
obj.items = match obj.items {
Some(ref mut existing) => {
existing.extend(CloudFrontOriginAccessIdentitySummaryListDeserializer::deserialize("Items", stack)?);
Some(existing.to_vec())
}
None => Some(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),
}
}
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CloudFrontOriginAccessIdentitySummary {
pub comment: String,
pub id: String,
pub s3_canonical_user_id: String,
}
struct CloudFrontOriginAccessIdentitySummaryDeserializer;
impl CloudFrontOriginAccessIdentitySummaryDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CloudFrontOriginAccessIdentitySummary, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = CloudFrontOriginAccessIdentitySummary::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"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),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct CloudFrontOriginAccessIdentitySummaryListDeserializer;
impl CloudFrontOriginAccessIdentitySummaryListDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<CloudFrontOriginAccessIdentitySummary>, XmlParseError> {
let mut obj = vec![];
start_element(tag_name, stack)?;
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "CloudFrontOriginAccessIdentitySummary" {
obj.push(
CloudFrontOriginAccessIdentitySummaryDeserializer::deserialize(
"CloudFrontOriginAccessIdentitySummary",
stack,
)?,
);
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
end_element(tag_name, stack)?;
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
struct CookieNameListDeserializer;
impl CookieNameListDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<String>, XmlParseError> {
let mut obj = vec![];
start_element(tag_name, stack)?;
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "Name" {
obj.push(StringDeserializer::deserialize("Name", stack)?);
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
end_element(tag_name, stack)?;
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
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(Default, Debug, Clone, PartialEq)]
pub struct CookieNames {
pub items: Option<Vec<String>>,
pub quantity: i64,
}
struct CookieNamesDeserializer;
impl CookieNamesDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CookieNames, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = CookieNames::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"Items" => {
obj.items = match obj.items {
Some(ref mut existing) => {
existing.extend(CookieNameListDeserializer::deserialize(
"Items", stack,
)?);
Some(existing.to_vec())
}
None => Some(CookieNameListDeserializer::deserialize("Items", stack)?),
};
}
"Quantity" => {
obj.quantity = IntegerDeserializer::deserialize("Quantity", stack)?;
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
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)?;
}
writer.write(xml::writer::XmlEvent::start_element("Quantity"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.quantity
)))?;
writer.write(xml::writer::XmlEvent::end_element())?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CookiePreference {
pub forward: String,
pub whitelisted_names: Option<CookieNames>,
}
struct CookiePreferenceDeserializer;
impl CookiePreferenceDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CookiePreference, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = CookiePreference::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"Forward" => {
obj.forward = ItemSelectionDeserializer::deserialize("Forward", stack)?;
}
"WhitelistedNames" => {
obj.whitelisted_names = Some(CookieNamesDeserializer::deserialize(
"WhitelistedNames",
stack,
)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
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))?;
writer.write(xml::writer::XmlEvent::start_element("Forward"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.forward
)))?;
writer.write(xml::writer::XmlEvent::end_element())?;
if let Some(ref value) = obj.whitelisted_names {
&CookieNamesSerializer::serialize(&mut writer, "WhitelistedNames", value)?;
}
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateCloudFrontOriginAccessIdentityRequest {
pub cloud_front_origin_access_identity_config: CloudFrontOriginAccessIdentityConfig,
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateCloudFrontOriginAccessIdentityResult {
pub cloud_front_origin_access_identity: Option<CloudFrontOriginAccessIdentity>,
pub e_tag: Option<String>,
pub location: Option<String>,
}
struct CreateCloudFrontOriginAccessIdentityResultDeserializer;
impl CreateCloudFrontOriginAccessIdentityResultDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, 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(Default, Debug, Clone, PartialEq)]
pub struct CreateDistributionRequest {
pub distribution_config: DistributionConfig,
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateDistributionResult {
pub distribution: Option<Distribution>,
pub e_tag: Option<String>,
pub location: Option<String>,
}
struct CreateDistributionResultDeserializer;
impl CreateDistributionResultDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CreateDistributionResult, XmlParseError> {
Ok(CreateDistributionResult {
distribution: Some(DistributionDeserializer::deserialize(
"Distribution",
stack,
)?),
..CreateDistributionResult::default()
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateDistributionWithTagsRequest {
pub distribution_config_with_tags: DistributionConfigWithTags,
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateDistributionWithTagsResult {
pub distribution: Option<Distribution>,
pub e_tag: Option<String>,
pub location: Option<String>,
}
struct CreateDistributionWithTagsResultDeserializer;
impl CreateDistributionWithTagsResultDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CreateDistributionWithTagsResult, XmlParseError> {
Ok(CreateDistributionWithTagsResult {
distribution: Some(DistributionDeserializer::deserialize(
"Distribution",
stack,
)?),
..CreateDistributionWithTagsResult::default()
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateInvalidationRequest {
pub distribution_id: String,
pub invalidation_batch: InvalidationBatch,
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateInvalidationResult {
pub invalidation: Option<Invalidation>,
pub location: Option<String>,
}
struct CreateInvalidationResultDeserializer;
impl CreateInvalidationResultDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CreateInvalidationResult, XmlParseError> {
Ok(CreateInvalidationResult {
invalidation: Some(InvalidationDeserializer::deserialize(
"Invalidation",
stack,
)?),
..CreateInvalidationResult::default()
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateStreamingDistributionRequest {
pub streaming_distribution_config: StreamingDistributionConfig,
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateStreamingDistributionResult {
pub e_tag: Option<String>,
pub location: Option<String>,
pub streaming_distribution: Option<StreamingDistribution>,
}
struct CreateStreamingDistributionResultDeserializer;
impl CreateStreamingDistributionResultDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CreateStreamingDistributionResult, XmlParseError> {
Ok(CreateStreamingDistributionResult {
streaming_distribution: Some(StreamingDistributionDeserializer::deserialize(
"StreamingDistribution",
stack,
)?),
..CreateStreamingDistributionResult::default()
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateStreamingDistributionWithTagsRequest {
pub streaming_distribution_config_with_tags: StreamingDistributionConfigWithTags,
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CreateStreamingDistributionWithTagsResult {
pub e_tag: Option<String>,
pub location: Option<String>,
pub streaming_distribution: Option<StreamingDistribution>,
}
struct CreateStreamingDistributionWithTagsResultDeserializer;
impl CreateStreamingDistributionWithTagsResultDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CreateStreamingDistributionWithTagsResult, XmlParseError> {
Ok(CreateStreamingDistributionWithTagsResult {
streaming_distribution: Some(StreamingDistributionDeserializer::deserialize(
"StreamingDistribution",
stack,
)?),
..CreateStreamingDistributionWithTagsResult::default()
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
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>,
}
struct CustomErrorResponseDeserializer;
impl CustomErrorResponseDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CustomErrorResponse, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = CustomErrorResponse::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"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),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
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 {
writer.write(xml::writer::XmlEvent::start_element("ErrorCachingMinTTL"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = value
)));
writer.write(xml::writer::XmlEvent::end_element())?;
}
writer.write(xml::writer::XmlEvent::start_element("ErrorCode"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.error_code
)))?;
writer.write(xml::writer::XmlEvent::end_element())?;
if let Some(ref value) = obj.response_code {
writer.write(xml::writer::XmlEvent::start_element("ResponseCode"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = value
)));
writer.write(xml::writer::XmlEvent::end_element())?;
}
if let Some(ref value) = obj.response_page_path {
writer.write(xml::writer::XmlEvent::start_element("ResponsePagePath"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = value
)));
writer.write(xml::writer::XmlEvent::end_element())?;
}
writer.write(xml::writer::XmlEvent::end_element())
}
}
struct CustomErrorResponseListDeserializer;
impl CustomErrorResponseListDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<CustomErrorResponse>, XmlParseError> {
let mut obj = vec![];
start_element(tag_name, stack)?;
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "CustomErrorResponse" {
obj.push(CustomErrorResponseDeserializer::deserialize(
"CustomErrorResponse",
stack,
)?);
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
end_element(tag_name, stack)?;
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
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(Default, Debug, Clone, PartialEq)]
pub struct CustomErrorResponses {
pub items: Option<Vec<CustomErrorResponse>>,
pub quantity: i64,
}
struct CustomErrorResponsesDeserializer;
impl CustomErrorResponsesDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CustomErrorResponses, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = CustomErrorResponses::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"Items" => {
obj.items = match obj.items {
Some(ref mut existing) => {
existing.extend(CustomErrorResponseListDeserializer::deserialize(
"Items", stack,
)?);
Some(existing.to_vec())
}
None => Some(CustomErrorResponseListDeserializer::deserialize(
"Items", stack,
)?),
};
}
"Quantity" => {
obj.quantity = IntegerDeserializer::deserialize("Quantity", stack)?;
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
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)?;
}
writer.write(xml::writer::XmlEvent::start_element("Quantity"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.quantity
)))?;
writer.write(xml::writer::XmlEvent::end_element())?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct CustomHeaders {
pub items: Option<Vec<OriginCustomHeader>>,
pub quantity: i64,
}
struct CustomHeadersDeserializer;
impl CustomHeadersDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CustomHeaders, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = CustomHeaders::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"Items" => {
obj.items = match obj.items {
Some(ref mut existing) => {
existing.extend(OriginCustomHeadersListDeserializer::deserialize(
"Items", stack,
)?);
Some(existing.to_vec())
}
None => Some(OriginCustomHeadersListDeserializer::deserialize(
"Items", stack,
)?),
};
}
"Quantity" => {
obj.quantity = IntegerDeserializer::deserialize("Quantity", stack)?;
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
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)?;
}
writer.write(xml::writer::XmlEvent::start_element("Quantity"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.quantity
)))?;
writer.write(xml::writer::XmlEvent::end_element())?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[derive(Default, Debug, Clone, PartialEq)]
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>,
}
struct CustomOriginConfigDeserializer;
impl CustomOriginConfigDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<CustomOriginConfig, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = CustomOriginConfig::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"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),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
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))?;
writer.write(xml::writer::XmlEvent::start_element("HTTPPort"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.http_port
)))?;
writer.write(xml::writer::XmlEvent::end_element())?;
writer.write(xml::writer::XmlEvent::start_element("HTTPSPort"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.https_port
)))?;
writer.write(xml::writer::XmlEvent::end_element())?;
if let Some(ref value) = obj.origin_keepalive_timeout {
writer.write(xml::writer::XmlEvent::start_element(
"OriginKeepaliveTimeout",
))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = value
)));
writer.write(xml::writer::XmlEvent::end_element())?;
}
writer.write(xml::writer::XmlEvent::start_element("OriginProtocolPolicy"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.origin_protocol_policy
)))?;
writer.write(xml::writer::XmlEvent::end_element())?;
if let Some(ref value) = obj.origin_read_timeout {
writer.write(xml::writer::XmlEvent::start_element("OriginReadTimeout"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = value
)));
writer.write(xml::writer::XmlEvent::end_element())?;
}
if let Some(ref value) = obj.origin_ssl_protocols {
&OriginSslProtocolsSerializer::serialize(&mut writer, "OriginSslProtocols", value)?;
}
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DefaultCacheBehavior {
pub allowed_methods: Option<AllowedMethods>,
pub compress: Option<bool>,
pub default_ttl: Option<i64>,
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,
}
struct DefaultCacheBehaviorDeserializer;
impl DefaultCacheBehaviorDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DefaultCacheBehavior, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = DefaultCacheBehavior::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"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)?);
}
"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),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
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 {
writer.write(xml::writer::XmlEvent::start_element("Compress"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = value
)));
writer.write(xml::writer::XmlEvent::end_element())?;
}
if let Some(ref value) = obj.default_ttl {
writer.write(xml::writer::XmlEvent::start_element("DefaultTTL"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = value
)));
writer.write(xml::writer::XmlEvent::end_element())?;
}
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 {
writer.write(xml::writer::XmlEvent::start_element("MaxTTL"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = value
)));
writer.write(xml::writer::XmlEvent::end_element())?;
}
writer.write(xml::writer::XmlEvent::start_element("MinTTL"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.min_ttl
)))?;
writer.write(xml::writer::XmlEvent::end_element())?;
if let Some(ref value) = obj.smooth_streaming {
writer.write(xml::writer::XmlEvent::start_element("SmoothStreaming"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = value
)));
writer.write(xml::writer::XmlEvent::end_element())?;
}
writer.write(xml::writer::XmlEvent::start_element("TargetOriginId"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.target_origin_id
)))?;
writer.write(xml::writer::XmlEvent::end_element())?;
TrustedSignersSerializer::serialize(&mut writer, "TrustedSigners", &obj.trusted_signers)?;
writer.write(xml::writer::XmlEvent::start_element("ViewerProtocolPolicy"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.viewer_protocol_policy
)))?;
writer.write(xml::writer::XmlEvent::end_element())?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DeleteCloudFrontOriginAccessIdentityRequest {
pub id: String,
pub if_match: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DeleteDistributionRequest {
pub id: String,
pub if_match: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DeleteServiceLinkedRoleRequest {
pub role_name: String,
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DeleteStreamingDistributionRequest {
pub id: String,
pub if_match: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct Distribution {
pub arn: String,
pub active_trusted_signers: ActiveTrustedSigners,
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,
}
struct DistributionDeserializer;
impl DistributionDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Distribution, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = Distribution::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"ARN" => {
obj.arn = StringDeserializer::deserialize("ARN", stack)?;
}
"ActiveTrustedSigners" => {
obj.active_trusted_signers = ActiveTrustedSignersDeserializer::deserialize(
"ActiveTrustedSigners",
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),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
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 origins: Origins,
pub price_class: Option<String>,
pub restrictions: Option<Restrictions>,
pub viewer_certificate: Option<ViewerCertificate>,
pub web_acl_id: Option<String>,
}
struct DistributionConfigDeserializer;
impl DistributionConfigDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DistributionConfig, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = DistributionConfig::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"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 = StringDeserializer::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)?);
}
"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),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
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)?;
}
writer.write(xml::writer::XmlEvent::start_element("CallerReference"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.caller_reference
)))?;
writer.write(xml::writer::XmlEvent::end_element())?;
writer.write(xml::writer::XmlEvent::start_element("Comment"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.comment
)))?;
writer.write(xml::writer::XmlEvent::end_element())?;
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 {
writer.write(xml::writer::XmlEvent::start_element("DefaultRootObject"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = value
)));
writer.write(xml::writer::XmlEvent::end_element())?;
}
writer.write(xml::writer::XmlEvent::start_element("Enabled"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.enabled
)))?;
writer.write(xml::writer::XmlEvent::end_element())?;
if let Some(ref value) = obj.http_version {
writer.write(xml::writer::XmlEvent::start_element("HttpVersion"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = value
)));
writer.write(xml::writer::XmlEvent::end_element())?;
}
if let Some(ref value) = obj.is_ipv6_enabled {
writer.write(xml::writer::XmlEvent::start_element("IsIPV6Enabled"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = value
)));
writer.write(xml::writer::XmlEvent::end_element())?;
}
if let Some(ref value) = obj.logging {
&LoggingConfigSerializer::serialize(&mut writer, "Logging", value)?;
}
OriginsSerializer::serialize(&mut writer, "Origins", &obj.origins)?;
if let Some(ref value) = obj.price_class {
writer.write(xml::writer::XmlEvent::start_element("PriceClass"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = value
)));
writer.write(xml::writer::XmlEvent::end_element())?;
}
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 {
writer.write(xml::writer::XmlEvent::start_element("WebACLId"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = value
)));
writer.write(xml::writer::XmlEvent::end_element())?;
}
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[derive(Default, Debug, Clone, PartialEq)]
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(Default, Debug, Clone, PartialEq)]
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,
}
struct DistributionListDeserializer;
impl DistributionListDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DistributionList, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = DistributionList::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"IsTruncated" => {
obj.is_truncated = BooleanDeserializer::deserialize("IsTruncated", stack)?;
}
"Items" => {
obj.items = match obj.items {
Some(ref mut existing) => {
existing.extend(DistributionSummaryListDeserializer::deserialize(
"Items", stack,
)?);
Some(existing.to_vec())
}
None => Some(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),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct DistributionSummary {
pub arn: String,
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 origins: Origins,
pub price_class: String,
pub restrictions: Restrictions,
pub status: String,
pub viewer_certificate: ViewerCertificate,
pub web_acl_id: String,
}
struct DistributionSummaryDeserializer;
impl DistributionSummaryDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<DistributionSummary, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = DistributionSummary::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"ARN" => {
obj.arn = StringDeserializer::deserialize("ARN", 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)?;
}
"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),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct DistributionSummaryListDeserializer;
impl DistributionSummaryListDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<DistributionSummary>, XmlParseError> {
let mut obj = vec![];
start_element(tag_name, stack)?;
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "DistributionSummary" {
obj.push(DistributionSummaryDeserializer::deserialize(
"DistributionSummary",
stack,
)?);
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
end_element(tag_name, stack)?;
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
struct EventTypeDeserializer;
impl EventTypeDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
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,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.to_string()
)))?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ForwardedValues {
pub cookies: CookiePreference,
pub headers: Option<Headers>,
pub query_string: bool,
pub query_string_cache_keys: Option<QueryStringCacheKeys>,
}
struct ForwardedValuesDeserializer;
impl ForwardedValuesDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ForwardedValues, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = ForwardedValues::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"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),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
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)?;
}
writer.write(xml::writer::XmlEvent::start_element("QueryString"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.query_string
)))?;
writer.write(xml::writer::XmlEvent::end_element())?;
if let Some(ref value) = obj.query_string_cache_keys {
&QueryStringCacheKeysSerializer::serialize(&mut writer, "QueryStringCacheKeys", value)?;
}
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct GeoRestriction {
pub items: Option<Vec<String>>,
pub quantity: i64,
pub restriction_type: String,
}
struct GeoRestrictionDeserializer;
impl GeoRestrictionDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<GeoRestriction, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = GeoRestriction::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"Items" => {
obj.items = match obj.items {
Some(ref mut existing) => {
existing
.extend(LocationListDeserializer::deserialize("Items", stack)?);
Some(existing.to_vec())
}
None => Some(LocationListDeserializer::deserialize("Items", stack)?),
};
}
"Quantity" => {
obj.quantity = IntegerDeserializer::deserialize("Quantity", stack)?;
}
"RestrictionType" => {
obj.restriction_type =
GeoRestrictionTypeDeserializer::deserialize("RestrictionType", stack)?;
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
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)?;
}
writer.write(xml::writer::XmlEvent::start_element("Quantity"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.quantity
)))?;
writer.write(xml::writer::XmlEvent::end_element())?;
writer.write(xml::writer::XmlEvent::start_element("RestrictionType"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.restriction_type
)))?;
writer.write(xml::writer::XmlEvent::end_element())?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
struct GeoRestrictionTypeDeserializer;
impl GeoRestrictionTypeDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
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,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.to_string()
)))?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct GetCloudFrontOriginAccessIdentityConfigRequest {
pub id: String,
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct GetCloudFrontOriginAccessIdentityConfigResult {
pub cloud_front_origin_access_identity_config: Option<CloudFrontOriginAccessIdentityConfig>,
pub e_tag: Option<String>,
}
struct GetCloudFrontOriginAccessIdentityConfigResultDeserializer;
impl GetCloudFrontOriginAccessIdentityConfigResultDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, 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(Default, Debug, Clone, PartialEq)]
pub struct GetCloudFrontOriginAccessIdentityRequest {
pub id: String,
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct GetCloudFrontOriginAccessIdentityResult {
pub cloud_front_origin_access_identity: Option<CloudFrontOriginAccessIdentity>,
pub e_tag: Option<String>,
}
struct GetCloudFrontOriginAccessIdentityResultDeserializer;
impl GetCloudFrontOriginAccessIdentityResultDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, 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(Default, Debug, Clone, PartialEq)]
pub struct GetDistributionConfigRequest {
pub id: String,
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct GetDistributionConfigResult {
pub distribution_config: Option<DistributionConfig>,
pub e_tag: Option<String>,
}
struct GetDistributionConfigResultDeserializer;
impl GetDistributionConfigResultDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<GetDistributionConfigResult, XmlParseError> {
Ok(GetDistributionConfigResult {
distribution_config: Some(DistributionConfigDeserializer::deserialize(
"DistributionConfig",
stack,
)?),
..GetDistributionConfigResult::default()
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct GetDistributionRequest {
pub id: String,
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct GetDistributionResult {
pub distribution: Option<Distribution>,
pub e_tag: Option<String>,
}
struct GetDistributionResultDeserializer;
impl GetDistributionResultDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<GetDistributionResult, XmlParseError> {
Ok(GetDistributionResult {
distribution: Some(DistributionDeserializer::deserialize(
"Distribution",
stack,
)?),
..GetDistributionResult::default()
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct GetInvalidationRequest {
pub distribution_id: String,
pub id: String,
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct GetInvalidationResult {
pub invalidation: Option<Invalidation>,
}
struct GetInvalidationResultDeserializer;
impl GetInvalidationResultDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<GetInvalidationResult, XmlParseError> {
Ok(GetInvalidationResult {
invalidation: Some(InvalidationDeserializer::deserialize(
"Invalidation",
stack,
)?),
..GetInvalidationResult::default()
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct GetStreamingDistributionConfigRequest {
pub id: String,
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct GetStreamingDistributionConfigResult {
pub e_tag: Option<String>,
pub streaming_distribution_config: Option<StreamingDistributionConfig>,
}
struct GetStreamingDistributionConfigResultDeserializer;
impl GetStreamingDistributionConfigResultDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, 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(Default, Debug, Clone, PartialEq)]
pub struct GetStreamingDistributionRequest {
pub id: String,
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct GetStreamingDistributionResult {
pub e_tag: Option<String>,
pub streaming_distribution: Option<StreamingDistribution>,
}
struct GetStreamingDistributionResultDeserializer;
impl GetStreamingDistributionResultDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<GetStreamingDistributionResult, XmlParseError> {
Ok(GetStreamingDistributionResult {
streaming_distribution: Some(StreamingDistributionDeserializer::deserialize(
"StreamingDistribution",
stack,
)?),
..GetStreamingDistributionResult::default()
})
}
}
struct HeaderListDeserializer;
impl HeaderListDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<String>, XmlParseError> {
let mut obj = vec![];
start_element(tag_name, stack)?;
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "Name" {
obj.push(StringDeserializer::deserialize("Name", stack)?);
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
end_element(tag_name, stack)?;
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
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(Default, Debug, Clone, PartialEq)]
pub struct Headers {
pub items: Option<Vec<String>>,
pub quantity: i64,
}
struct HeadersDeserializer;
impl HeadersDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Headers, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = Headers::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"Items" => {
obj.items = match obj.items {
Some(ref mut existing) => {
existing
.extend(HeaderListDeserializer::deserialize("Items", stack)?);
Some(existing.to_vec())
}
None => Some(HeaderListDeserializer::deserialize("Items", stack)?),
};
}
"Quantity" => {
obj.quantity = IntegerDeserializer::deserialize("Quantity", stack)?;
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
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)?;
}
writer.write(xml::writer::XmlEvent::start_element("Quantity"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.quantity
)))?;
writer.write(xml::writer::XmlEvent::end_element())?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
struct HttpVersionDeserializer;
impl HttpVersionDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
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,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.to_string()
)))?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
struct IntegerDeserializer;
impl IntegerDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<i64, XmlParseError> {
start_element(tag_name, stack)?;
let obj = i64::from_str(characters(stack)?.as_ref()).unwrap();
end_element(tag_name, stack)?;
Ok(obj)
}
}
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,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.to_string()
)))?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct Invalidation {
pub create_time: String,
pub id: String,
pub invalidation_batch: InvalidationBatch,
pub status: String,
}
struct InvalidationDeserializer;
impl InvalidationDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Invalidation, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = Invalidation::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"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),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct InvalidationBatch {
pub caller_reference: String,
pub paths: Paths,
}
struct InvalidationBatchDeserializer;
impl InvalidationBatchDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<InvalidationBatch, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = InvalidationBatch::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"CallerReference" => {
obj.caller_reference =
StringDeserializer::deserialize("CallerReference", stack)?;
}
"Paths" => {
obj.paths = PathsDeserializer::deserialize("Paths", stack)?;
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
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))?;
writer.write(xml::writer::XmlEvent::start_element("CallerReference"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.caller_reference
)))?;
writer.write(xml::writer::XmlEvent::end_element())?;
PathsSerializer::serialize(&mut writer, "Paths", &obj.paths)?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[derive(Default, Debug, Clone, PartialEq)]
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,
}
struct InvalidationListDeserializer;
impl InvalidationListDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<InvalidationList, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = InvalidationList::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"IsTruncated" => {
obj.is_truncated = BooleanDeserializer::deserialize("IsTruncated", stack)?;
}
"Items" => {
obj.items = match obj.items {
Some(ref mut existing) => {
existing.extend(InvalidationSummaryListDeserializer::deserialize(
"Items", stack,
)?);
Some(existing.to_vec())
}
None => Some(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),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct InvalidationSummary {
pub create_time: String,
pub id: String,
pub status: String,
}
struct InvalidationSummaryDeserializer;
impl InvalidationSummaryDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<InvalidationSummary, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = InvalidationSummary::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"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),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct InvalidationSummaryListDeserializer;
impl InvalidationSummaryListDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<InvalidationSummary>, XmlParseError> {
let mut obj = vec![];
start_element(tag_name, stack)?;
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "InvalidationSummary" {
obj.push(InvalidationSummaryDeserializer::deserialize(
"InvalidationSummary",
stack,
)?);
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
end_element(tag_name, stack)?;
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
struct ItemSelectionDeserializer;
impl ItemSelectionDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
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,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.to_string()
)))?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
struct KeyPairIdListDeserializer;
impl KeyPairIdListDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<String>, XmlParseError> {
let mut obj = vec![];
start_element(tag_name, stack)?;
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "KeyPairId" {
obj.push(StringDeserializer::deserialize("KeyPairId", stack)?);
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
end_element(tag_name, stack)?;
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct KeyPairIds {
pub items: Option<Vec<String>>,
pub quantity: i64,
}
struct KeyPairIdsDeserializer;
impl KeyPairIdsDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<KeyPairIds, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = KeyPairIds::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"Items" => {
obj.items = match obj.items {
Some(ref mut existing) => {
existing.extend(KeyPairIdListDeserializer::deserialize(
"Items", stack,
)?);
Some(existing.to_vec())
}
None => Some(KeyPairIdListDeserializer::deserialize("Items", stack)?),
};
}
"Quantity" => {
obj.quantity = IntegerDeserializer::deserialize("Quantity", stack)?;
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct LambdaFunctionAssociation {
pub event_type: Option<String>,
pub lambda_function_arn: Option<String>,
}
struct LambdaFunctionAssociationDeserializer;
impl LambdaFunctionAssociationDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<LambdaFunctionAssociation, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = LambdaFunctionAssociation::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"EventType" => {
obj.event_type =
Some(EventTypeDeserializer::deserialize("EventType", stack)?);
}
"LambdaFunctionARN" => {
obj.lambda_function_arn =
Some(StringDeserializer::deserialize("LambdaFunctionARN", stack)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
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))?;
if let Some(ref value) = obj.event_type {
writer.write(xml::writer::XmlEvent::start_element("EventType"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = value
)));
writer.write(xml::writer::XmlEvent::end_element())?;
}
if let Some(ref value) = obj.lambda_function_arn {
writer.write(xml::writer::XmlEvent::start_element("LambdaFunctionARN"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = value
)));
writer.write(xml::writer::XmlEvent::end_element())?;
}
writer.write(xml::writer::XmlEvent::end_element())
}
}
struct LambdaFunctionAssociationListDeserializer;
impl LambdaFunctionAssociationListDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<LambdaFunctionAssociation>, XmlParseError> {
let mut obj = vec![];
start_element(tag_name, stack)?;
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "LambdaFunctionAssociation" {
obj.push(LambdaFunctionAssociationDeserializer::deserialize(
"LambdaFunctionAssociation",
stack,
)?);
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
end_element(tag_name, stack)?;
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
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(Default, Debug, Clone, PartialEq)]
pub struct LambdaFunctionAssociations {
pub items: Option<Vec<LambdaFunctionAssociation>>,
pub quantity: i64,
}
struct LambdaFunctionAssociationsDeserializer;
impl LambdaFunctionAssociationsDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<LambdaFunctionAssociations, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = LambdaFunctionAssociations::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"Items" => {
obj.items = match obj.items {
Some(ref mut existing) => {
existing.extend(
LambdaFunctionAssociationListDeserializer::deserialize(
"Items", stack,
)?,
);
Some(existing.to_vec())
}
None => Some(LambdaFunctionAssociationListDeserializer::deserialize(
"Items", stack,
)?),
};
}
"Quantity" => {
obj.quantity = IntegerDeserializer::deserialize("Quantity", stack)?;
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
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)?;
}
writer.write(xml::writer::XmlEvent::start_element("Quantity"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.quantity
)))?;
writer.write(xml::writer::XmlEvent::end_element())?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ListCloudFrontOriginAccessIdentitiesRequest {
pub marker: Option<String>,
pub max_items: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ListCloudFrontOriginAccessIdentitiesResult {
pub cloud_front_origin_access_identity_list: Option<CloudFrontOriginAccessIdentityList>,
}
struct ListCloudFrontOriginAccessIdentitiesResultDeserializer;
impl ListCloudFrontOriginAccessIdentitiesResultDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, 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(Default, Debug, Clone, PartialEq)]
pub struct ListDistributionsByWebACLIdRequest {
pub marker: Option<String>,
pub max_items: Option<String>,
pub web_acl_id: String,
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ListDistributionsByWebACLIdResult {
pub distribution_list: Option<DistributionList>,
}
struct ListDistributionsByWebACLIdResultDeserializer;
impl ListDistributionsByWebACLIdResultDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ListDistributionsByWebACLIdResult, XmlParseError> {
Ok(ListDistributionsByWebACLIdResult {
distribution_list: Some(DistributionListDeserializer::deserialize(
"DistributionList",
stack,
)?),
..ListDistributionsByWebACLIdResult::default()
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ListDistributionsRequest {
pub marker: Option<String>,
pub max_items: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ListDistributionsResult {
pub distribution_list: Option<DistributionList>,
}
struct ListDistributionsResultDeserializer;
impl ListDistributionsResultDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ListDistributionsResult, XmlParseError> {
Ok(ListDistributionsResult {
distribution_list: Some(DistributionListDeserializer::deserialize(
"DistributionList",
stack,
)?),
..ListDistributionsResult::default()
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ListInvalidationsRequest {
pub distribution_id: String,
pub marker: Option<String>,
pub max_items: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ListInvalidationsResult {
pub invalidation_list: Option<InvalidationList>,
}
struct ListInvalidationsResultDeserializer;
impl ListInvalidationsResultDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ListInvalidationsResult, XmlParseError> {
Ok(ListInvalidationsResult {
invalidation_list: Some(InvalidationListDeserializer::deserialize(
"InvalidationList",
stack,
)?),
..ListInvalidationsResult::default()
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ListStreamingDistributionsRequest {
pub marker: Option<String>,
pub max_items: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ListStreamingDistributionsResult {
pub streaming_distribution_list: Option<StreamingDistributionList>,
}
struct ListStreamingDistributionsResultDeserializer;
impl ListStreamingDistributionsResultDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, 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(Default, Debug, Clone, PartialEq)]
pub struct ListTagsForResourceRequest {
pub resource: String,
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ListTagsForResourceResult {
pub tags: Tags,
}
struct ListTagsForResourceResultDeserializer;
impl ListTagsForResourceResultDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ListTagsForResourceResult, XmlParseError> {
Ok(ListTagsForResourceResult {
tags: TagsDeserializer::deserialize("Tags", stack)?,
..ListTagsForResourceResult::default()
})
}
}
struct LocationListDeserializer;
impl LocationListDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<String>, XmlParseError> {
let mut obj = vec![];
start_element(tag_name, stack)?;
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "Location" {
obj.push(StringDeserializer::deserialize("Location", stack)?);
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
end_element(tag_name, stack)?;
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
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(Default, Debug, Clone, PartialEq)]
pub struct LoggingConfig {
pub bucket: String,
pub enabled: bool,
pub include_cookies: bool,
pub prefix: String,
}
struct LoggingConfigDeserializer;
impl LoggingConfigDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<LoggingConfig, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = LoggingConfig::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"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),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
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))?;
writer.write(xml::writer::XmlEvent::start_element("Bucket"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.bucket
)))?;
writer.write(xml::writer::XmlEvent::end_element())?;
writer.write(xml::writer::XmlEvent::start_element("Enabled"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.enabled
)))?;
writer.write(xml::writer::XmlEvent::end_element())?;
writer.write(xml::writer::XmlEvent::start_element("IncludeCookies"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.include_cookies
)))?;
writer.write(xml::writer::XmlEvent::end_element())?;
writer.write(xml::writer::XmlEvent::start_element("Prefix"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.prefix
)))?;
writer.write(xml::writer::XmlEvent::end_element())?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
struct LongDeserializer;
impl LongDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<i64, XmlParseError> {
start_element(tag_name, stack)?;
let obj = i64::from_str(characters(stack)?.as_ref()).unwrap();
end_element(tag_name, stack)?;
Ok(obj)
}
}
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,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.to_string()
)))?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
struct MethodDeserializer;
impl MethodDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
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,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.to_string()
)))?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
struct MethodsListDeserializer;
impl MethodsListDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<String>, XmlParseError> {
let mut obj = vec![];
start_element(tag_name, stack)?;
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "Method" {
obj.push(MethodDeserializer::deserialize("Method", stack)?);
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
end_element(tag_name, stack)?;
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
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(())
}
}
struct MinimumProtocolVersionDeserializer;
impl MinimumProtocolVersionDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
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,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.to_string()
)))?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct Origin {
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>,
}
struct OriginDeserializer;
impl OriginDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Origin, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = Origin::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"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),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
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.custom_headers {
&CustomHeadersSerializer::serialize(&mut writer, "CustomHeaders", value)?;
}
if let Some(ref value) = obj.custom_origin_config {
&CustomOriginConfigSerializer::serialize(&mut writer, "CustomOriginConfig", value)?;
}
writer.write(xml::writer::XmlEvent::start_element("DomainName"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.domain_name
)))?;
writer.write(xml::writer::XmlEvent::end_element())?;
writer.write(xml::writer::XmlEvent::start_element("Id"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.id
)))?;
writer.write(xml::writer::XmlEvent::end_element())?;
if let Some(ref value) = obj.origin_path {
writer.write(xml::writer::XmlEvent::start_element("OriginPath"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = value
)));
writer.write(xml::writer::XmlEvent::end_element())?;
}
if let Some(ref value) = obj.s3_origin_config {
&S3OriginConfigSerializer::serialize(&mut writer, "S3OriginConfig", value)?;
}
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct OriginCustomHeader {
pub header_name: String,
pub header_value: String,
}
struct OriginCustomHeaderDeserializer;
impl OriginCustomHeaderDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<OriginCustomHeader, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = OriginCustomHeader::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"HeaderName" => {
obj.header_name = StringDeserializer::deserialize("HeaderName", stack)?;
}
"HeaderValue" => {
obj.header_value = StringDeserializer::deserialize("HeaderValue", stack)?;
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
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))?;
writer.write(xml::writer::XmlEvent::start_element("HeaderName"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.header_name
)))?;
writer.write(xml::writer::XmlEvent::end_element())?;
writer.write(xml::writer::XmlEvent::start_element("HeaderValue"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.header_value
)))?;
writer.write(xml::writer::XmlEvent::end_element())?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
struct OriginCustomHeadersListDeserializer;
impl OriginCustomHeadersListDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<OriginCustomHeader>, XmlParseError> {
let mut obj = vec![];
start_element(tag_name, stack)?;
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "OriginCustomHeader" {
obj.push(OriginCustomHeaderDeserializer::deserialize(
"OriginCustomHeader",
stack,
)?);
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
end_element(tag_name, stack)?;
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
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(())
}
}
struct OriginListDeserializer;
impl OriginListDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<Origin>, XmlParseError> {
let mut obj = vec![];
start_element(tag_name, stack)?;
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "Origin" {
obj.push(OriginDeserializer::deserialize("Origin", stack)?);
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
end_element(tag_name, stack)?;
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
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(())
}
}
struct OriginProtocolPolicyDeserializer;
impl OriginProtocolPolicyDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
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,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.to_string()
)))?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct OriginSslProtocols {
pub items: Vec<String>,
pub quantity: i64,
}
struct OriginSslProtocolsDeserializer;
impl OriginSslProtocolsDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<OriginSslProtocols, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = OriginSslProtocols::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"Items" => {
obj.items
.extend(SslProtocolsListDeserializer::deserialize("Items", stack)?);
}
"Quantity" => {
obj.quantity = IntegerDeserializer::deserialize("Quantity", stack)?;
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
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)?;
writer.write(xml::writer::XmlEvent::start_element("Quantity"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.quantity
)))?;
writer.write(xml::writer::XmlEvent::end_element())?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct Origins {
pub items: Option<Vec<Origin>>,
pub quantity: i64,
}
struct OriginsDeserializer;
impl OriginsDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Origins, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = Origins::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"Items" => {
obj.items = match obj.items {
Some(ref mut existing) => {
existing
.extend(OriginListDeserializer::deserialize("Items", stack)?);
Some(existing.to_vec())
}
None => Some(OriginListDeserializer::deserialize("Items", stack)?),
};
}
"Quantity" => {
obj.quantity = IntegerDeserializer::deserialize("Quantity", stack)?;
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
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))?;
if let Some(ref value) = obj.items {
&OriginListSerializer::serialize(&mut writer, "Items", value)?;
}
writer.write(xml::writer::XmlEvent::start_element("Quantity"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.quantity
)))?;
writer.write(xml::writer::XmlEvent::end_element())?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
struct PathListDeserializer;
impl PathListDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<String>, XmlParseError> {
let mut obj = vec![];
start_element(tag_name, stack)?;
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "Path" {
obj.push(StringDeserializer::deserialize("Path", stack)?);
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
end_element(tag_name, stack)?;
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
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(Default, Debug, Clone, PartialEq)]
pub struct Paths {
pub items: Option<Vec<String>>,
pub quantity: i64,
}
struct PathsDeserializer;
impl PathsDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Paths, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = Paths::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"Items" => {
obj.items = match obj.items {
Some(ref mut existing) => {
existing.extend(PathListDeserializer::deserialize("Items", stack)?);
Some(existing.to_vec())
}
None => Some(PathListDeserializer::deserialize("Items", stack)?),
};
}
"Quantity" => {
obj.quantity = IntegerDeserializer::deserialize("Quantity", stack)?;
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
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)?;
}
writer.write(xml::writer::XmlEvent::start_element("Quantity"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.quantity
)))?;
writer.write(xml::writer::XmlEvent::end_element())?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
struct PriceClassDeserializer;
impl PriceClassDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
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,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.to_string()
)))?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct QueryStringCacheKeys {
pub items: Option<Vec<String>>,
pub quantity: i64,
}
struct QueryStringCacheKeysDeserializer;
impl QueryStringCacheKeysDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<QueryStringCacheKeys, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = QueryStringCacheKeys::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"Items" => {
obj.items = match obj.items {
Some(ref mut existing) => {
existing.extend(QueryStringCacheKeysListDeserializer::deserialize(
"Items", stack,
)?);
Some(existing.to_vec())
}
None => Some(QueryStringCacheKeysListDeserializer::deserialize(
"Items", stack,
)?),
};
}
"Quantity" => {
obj.quantity = IntegerDeserializer::deserialize("Quantity", stack)?;
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
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)?;
}
writer.write(xml::writer::XmlEvent::start_element("Quantity"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.quantity
)))?;
writer.write(xml::writer::XmlEvent::end_element())?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
struct QueryStringCacheKeysListDeserializer;
impl QueryStringCacheKeysListDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<String>, XmlParseError> {
let mut obj = vec![];
start_element(tag_name, stack)?;
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "Name" {
obj.push(StringDeserializer::deserialize("Name", stack)?);
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
end_element(tag_name, stack)?;
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
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,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.to_string()
)))?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct Restrictions {
pub geo_restriction: GeoRestriction,
}
struct RestrictionsDeserializer;
impl RestrictionsDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Restrictions, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = Restrictions::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"GeoRestriction" => {
obj.geo_restriction =
GeoRestrictionDeserializer::deserialize("GeoRestriction", stack)?;
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
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(Default, Debug, Clone, PartialEq)]
pub struct S3Origin {
pub domain_name: String,
pub origin_access_identity: String,
}
struct S3OriginDeserializer;
impl S3OriginDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<S3Origin, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = S3Origin::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"DomainName" => {
obj.domain_name = StringDeserializer::deserialize("DomainName", stack)?;
}
"OriginAccessIdentity" => {
obj.origin_access_identity =
StringDeserializer::deserialize("OriginAccessIdentity", stack)?;
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
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))?;
writer.write(xml::writer::XmlEvent::start_element("DomainName"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.domain_name
)))?;
writer.write(xml::writer::XmlEvent::end_element())?;
writer.write(xml::writer::XmlEvent::start_element("OriginAccessIdentity"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.origin_access_identity
)))?;
writer.write(xml::writer::XmlEvent::end_element())?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct S3OriginConfig {
pub origin_access_identity: String,
}
struct S3OriginConfigDeserializer;
impl S3OriginConfigDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<S3OriginConfig, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = S3OriginConfig::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"OriginAccessIdentity" => {
obj.origin_access_identity =
StringDeserializer::deserialize("OriginAccessIdentity", stack)?;
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
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))?;
writer.write(xml::writer::XmlEvent::start_element("OriginAccessIdentity"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.origin_access_identity
)))?;
writer.write(xml::writer::XmlEvent::end_element())?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
struct SSLSupportMethodDeserializer;
impl SSLSupportMethodDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
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,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.to_string()
)))?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct Signer {
pub aws_account_number: Option<String>,
pub key_pair_ids: Option<KeyPairIds>,
}
struct SignerDeserializer;
impl SignerDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Signer, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = Signer::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"AwsAccountNumber" => {
obj.aws_account_number =
Some(StringDeserializer::deserialize("AwsAccountNumber", stack)?);
}
"KeyPairIds" => {
obj.key_pair_ids =
Some(KeyPairIdsDeserializer::deserialize("KeyPairIds", stack)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct SignerListDeserializer;
impl SignerListDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<Signer>, XmlParseError> {
let mut obj = vec![];
start_element(tag_name, stack)?;
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "Signer" {
obj.push(SignerDeserializer::deserialize("Signer", stack)?);
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
end_element(tag_name, stack)?;
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
struct SslProtocolDeserializer;
impl SslProtocolDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
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,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.to_string()
)))?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
struct SslProtocolsListDeserializer;
impl SslProtocolsListDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<String>, XmlParseError> {
let mut obj = vec![];
start_element(tag_name, stack)?;
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "SslProtocol" {
obj.push(SslProtocolDeserializer::deserialize("SslProtocol", stack)?);
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
end_element(tag_name, stack)?;
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
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(())
}
}
#[derive(Default, Debug, Clone, PartialEq)]
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,
}
struct StreamingDistributionDeserializer;
impl StreamingDistributionDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<StreamingDistribution, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = StreamingDistribution::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"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),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
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,
}
struct StreamingDistributionConfigDeserializer;
impl StreamingDistributionConfigDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<StreamingDistributionConfig, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = StreamingDistributionConfig::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"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),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
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)?;
}
writer.write(xml::writer::XmlEvent::start_element("CallerReference"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.caller_reference
)))?;
writer.write(xml::writer::XmlEvent::end_element())?;
writer.write(xml::writer::XmlEvent::start_element("Comment"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.comment
)))?;
writer.write(xml::writer::XmlEvent::end_element())?;
writer.write(xml::writer::XmlEvent::start_element("Enabled"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.enabled
)))?;
writer.write(xml::writer::XmlEvent::end_element())?;
if let Some(ref value) = obj.logging {
&StreamingLoggingConfigSerializer::serialize(&mut writer, "Logging", value)?;
}
if let Some(ref value) = obj.price_class {
writer.write(xml::writer::XmlEvent::start_element("PriceClass"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = value
)));
writer.write(xml::writer::XmlEvent::end_element())?;
}
S3OriginSerializer::serialize(&mut writer, "S3Origin", &obj.s3_origin)?;
TrustedSignersSerializer::serialize(&mut writer, "TrustedSigners", &obj.trusted_signers)?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[derive(Default, Debug, Clone, PartialEq)]
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(Default, Debug, Clone, PartialEq)]
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,
}
struct StreamingDistributionListDeserializer;
impl StreamingDistributionListDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<StreamingDistributionList, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = StreamingDistributionList::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"IsTruncated" => {
obj.is_truncated = BooleanDeserializer::deserialize("IsTruncated", stack)?;
}
"Items" => {
obj.items = match obj.items {
Some(ref mut existing) => {
existing.extend(
StreamingDistributionSummaryListDeserializer::deserialize(
"Items", stack,
)?,
);
Some(existing.to_vec())
}
None => {
Some(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),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
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,
}
struct StreamingDistributionSummaryDeserializer;
impl StreamingDistributionSummaryDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<StreamingDistributionSummary, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = StreamingDistributionSummary::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"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),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
struct StreamingDistributionSummaryListDeserializer;
impl StreamingDistributionSummaryListDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<StreamingDistributionSummary>, XmlParseError> {
let mut obj = vec![];
start_element(tag_name, stack)?;
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "StreamingDistributionSummary" {
obj.push(StreamingDistributionSummaryDeserializer::deserialize(
"StreamingDistributionSummary",
stack,
)?);
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
end_element(tag_name, stack)?;
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct StreamingLoggingConfig {
pub bucket: String,
pub enabled: bool,
pub prefix: String,
}
struct StreamingLoggingConfigDeserializer;
impl StreamingLoggingConfigDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<StreamingLoggingConfig, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = StreamingLoggingConfig::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"Bucket" => {
obj.bucket = StringDeserializer::deserialize("Bucket", stack)?;
}
"Enabled" => {
obj.enabled = BooleanDeserializer::deserialize("Enabled", stack)?;
}
"Prefix" => {
obj.prefix = StringDeserializer::deserialize("Prefix", stack)?;
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
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))?;
writer.write(xml::writer::XmlEvent::start_element("Bucket"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.bucket
)))?;
writer.write(xml::writer::XmlEvent::end_element())?;
writer.write(xml::writer::XmlEvent::start_element("Enabled"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.enabled
)))?;
writer.write(xml::writer::XmlEvent::end_element())?;
writer.write(xml::writer::XmlEvent::start_element("Prefix"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.prefix
)))?;
writer.write(xml::writer::XmlEvent::end_element())?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
struct StringDeserializer;
impl StringDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
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,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.to_string()
)))?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct Tag {
pub key: String,
pub value: Option<String>,
}
struct TagDeserializer;
impl TagDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Tag, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = Tag::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"Key" => {
obj.key = TagKeyDeserializer::deserialize("Key", stack)?;
}
"Value" => {
obj.value = Some(TagValueDeserializer::deserialize("Value", stack)?);
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
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))?;
writer.write(xml::writer::XmlEvent::start_element("Key"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.key
)))?;
writer.write(xml::writer::XmlEvent::end_element())?;
if let Some(ref value) = obj.value {
writer.write(xml::writer::XmlEvent::start_element("Value"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = value
)));
writer.write(xml::writer::XmlEvent::end_element())?;
}
writer.write(xml::writer::XmlEvent::end_element())
}
}
struct TagKeyDeserializer;
impl TagKeyDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
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,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.to_string()
)))?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
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(Default, Debug, Clone, PartialEq)]
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())
}
}
struct TagListDeserializer;
impl TagListDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Vec<Tag>, XmlParseError> {
let mut obj = vec![];
start_element(tag_name, stack)?;
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => {
if name == "Tag" {
obj.push(TagDeserializer::deserialize("Tag", stack)?);
} else {
skip_tree(stack);
}
}
DeserializerNext::Close => {
end_element(tag_name, stack)?;
break;
}
DeserializerNext::Skip => {
stack.next();
}
}
}
Ok(obj)
}
}
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(Default, Debug, Clone, PartialEq)]
pub struct TagResourceRequest {
pub resource: String,
pub tags: Tags,
}
struct TagValueDeserializer;
impl TagValueDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
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,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.to_string()
)))?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct Tags {
pub items: Option<Vec<Tag>>,
}
struct TagsDeserializer;
impl TagsDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<Tags, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = Tags::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"Items" => {
obj.items = match obj.items {
Some(ref mut existing) => {
existing.extend(TagListDeserializer::deserialize("Items", stack)?);
Some(existing.to_vec())
}
None => Some(TagListDeserializer::deserialize("Items", stack)?),
};
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
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())
}
}
struct TimestampDeserializer;
impl TimestampDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct TrustedSigners {
pub enabled: bool,
pub items: Option<Vec<String>>,
pub quantity: i64,
}
struct TrustedSignersDeserializer;
impl TrustedSignersDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<TrustedSigners, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = TrustedSigners::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"Enabled" => {
obj.enabled = BooleanDeserializer::deserialize("Enabled", stack)?;
}
"Items" => {
obj.items = match obj.items {
Some(ref mut existing) => {
existing.extend(AwsAccountNumberListDeserializer::deserialize(
"Items", stack,
)?);
Some(existing.to_vec())
}
None => Some(AwsAccountNumberListDeserializer::deserialize(
"Items", stack,
)?),
};
}
"Quantity" => {
obj.quantity = IntegerDeserializer::deserialize("Quantity", stack)?;
}
_ => skip_tree(stack),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
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))?;
writer.write(xml::writer::XmlEvent::start_element("Enabled"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.enabled
)))?;
writer.write(xml::writer::XmlEvent::end_element())?;
if let Some(ref value) = obj.items {
&AwsAccountNumberListSerializer::serialize(&mut writer, "Items", value)?;
}
writer.write(xml::writer::XmlEvent::start_element("Quantity"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.quantity
)))?;
writer.write(xml::writer::XmlEvent::end_element())?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct UntagResourceRequest {
pub resource: String,
pub tag_keys: TagKeys,
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct UpdateCloudFrontOriginAccessIdentityRequest {
pub cloud_front_origin_access_identity_config: CloudFrontOriginAccessIdentityConfig,
pub id: String,
pub if_match: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct UpdateCloudFrontOriginAccessIdentityResult {
pub cloud_front_origin_access_identity: Option<CloudFrontOriginAccessIdentity>,
pub e_tag: Option<String>,
}
struct UpdateCloudFrontOriginAccessIdentityResultDeserializer;
impl UpdateCloudFrontOriginAccessIdentityResultDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, 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(Default, Debug, Clone, PartialEq)]
pub struct UpdateDistributionRequest {
pub distribution_config: DistributionConfig,
pub id: String,
pub if_match: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct UpdateDistributionResult {
pub distribution: Option<Distribution>,
pub e_tag: Option<String>,
}
struct UpdateDistributionResultDeserializer;
impl UpdateDistributionResultDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<UpdateDistributionResult, XmlParseError> {
Ok(UpdateDistributionResult {
distribution: Some(DistributionDeserializer::deserialize(
"Distribution",
stack,
)?),
..UpdateDistributionResult::default()
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct UpdateStreamingDistributionRequest {
pub id: String,
pub if_match: Option<String>,
pub streaming_distribution_config: StreamingDistributionConfig,
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct UpdateStreamingDistributionResult {
pub e_tag: Option<String>,
pub streaming_distribution: Option<StreamingDistribution>,
}
struct UpdateStreamingDistributionResultDeserializer;
impl UpdateStreamingDistributionResultDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<UpdateStreamingDistributionResult, XmlParseError> {
Ok(UpdateStreamingDistributionResult {
streaming_distribution: Some(StreamingDistributionDeserializer::deserialize(
"StreamingDistribution",
stack,
)?),
..UpdateStreamingDistributionResult::default()
})
}
}
#[derive(Default, Debug, Clone, PartialEq)]
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>,
}
struct ViewerCertificateDeserializer;
impl ViewerCertificateDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<ViewerCertificate, XmlParseError> {
start_element(tag_name, stack)?;
let mut obj = ViewerCertificate::default();
loop {
let next_event = match stack.peek() {
Some(&Ok(XmlEvent::EndElement { ref name, .. })) => DeserializerNext::Close,
Some(&Ok(XmlEvent::StartElement { ref name, .. })) => {
DeserializerNext::Element(name.local_name.to_owned())
}
_ => DeserializerNext::Skip,
};
match next_event {
DeserializerNext::Element(name) => match &name[..] {
"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),
},
DeserializerNext::Close => break,
DeserializerNext::Skip => {
stack.next();
}
}
}
end_element(tag_name, stack)?;
Ok(obj)
}
}
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 {
writer.write(xml::writer::XmlEvent::start_element("ACMCertificateArn"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = value
)));
writer.write(xml::writer::XmlEvent::end_element())?;
}
if let Some(ref value) = obj.cloud_front_default_certificate {
writer.write(xml::writer::XmlEvent::start_element(
"CloudFrontDefaultCertificate",
))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = value
)));
writer.write(xml::writer::XmlEvent::end_element())?;
}
if let Some(ref value) = obj.iam_certificate_id {
writer.write(xml::writer::XmlEvent::start_element("IAMCertificateId"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = value
)));
writer.write(xml::writer::XmlEvent::end_element())?;
}
if let Some(ref value) = obj.minimum_protocol_version {
writer.write(xml::writer::XmlEvent::start_element(
"MinimumProtocolVersion",
))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = value
)));
writer.write(xml::writer::XmlEvent::end_element())?;
}
if let Some(ref value) = obj.ssl_support_method {
writer.write(xml::writer::XmlEvent::start_element("SSLSupportMethod"))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = value
)));
writer.write(xml::writer::XmlEvent::end_element())?;
}
writer.write(xml::writer::XmlEvent::end_element())
}
}
struct ViewerProtocolPolicyDeserializer;
impl ViewerProtocolPolicyDeserializer {
#[allow(unused_variables)]
fn deserialize<'a, T: Peek + Next>(
tag_name: &str,
stack: &mut T,
) -> Result<String, XmlParseError> {
start_element(tag_name, stack)?;
let obj = characters(stack)?;
end_element(tag_name, stack)?;
Ok(obj)
}
}
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,
{
writer.write(xml::writer::XmlEvent::start_element(name))?;
writer.write(xml::writer::XmlEvent::characters(&format!(
"{value}",
value = obj.to_string()
)))?;
writer.write(xml::writer::XmlEvent::end_element())
}
}
#[derive(Debug, PartialEq)]
pub enum CreateCloudFrontOriginAccessIdentityError {
CloudFrontOriginAccessIdentityAlreadyExists(String),
InconsistentQuantities(String),
InvalidArgument(String),
MissingBody(String),
TooManyCloudFrontOriginAccessIdentities(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CreateCloudFrontOriginAccessIdentityError {
pub fn from_response(res: BufferedHttpResponse) -> CreateCloudFrontOriginAccessIdentityError {
{
let reader = EventReader::new(res.body.as_slice());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"CloudFrontOriginAccessIdentityAlreadyExists" => return CreateCloudFrontOriginAccessIdentityError::CloudFrontOriginAccessIdentityAlreadyExists(String::from(parsed_error.message)),"InconsistentQuantities" => return CreateCloudFrontOriginAccessIdentityError::InconsistentQuantities(String::from(parsed_error.message)),"InvalidArgument" => return CreateCloudFrontOriginAccessIdentityError::InvalidArgument(String::from(parsed_error.message)),"MissingBody" => return CreateCloudFrontOriginAccessIdentityError::MissingBody(String::from(parsed_error.message)),"TooManyCloudFrontOriginAccessIdentities" => return CreateCloudFrontOriginAccessIdentityError::TooManyCloudFrontOriginAccessIdentities(String::from(parsed_error.message)),_ => {}
}
}
}
CreateCloudFrontOriginAccessIdentityError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for CreateCloudFrontOriginAccessIdentityError {
fn from(err: XmlParseError) -> CreateCloudFrontOriginAccessIdentityError {
let XmlParseError(message) = err;
CreateCloudFrontOriginAccessIdentityError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for CreateCloudFrontOriginAccessIdentityError {
fn from(err: CredentialsError) -> CreateCloudFrontOriginAccessIdentityError {
CreateCloudFrontOriginAccessIdentityError::Credentials(err)
}
}
impl From<HttpDispatchError> for CreateCloudFrontOriginAccessIdentityError {
fn from(err: HttpDispatchError) -> CreateCloudFrontOriginAccessIdentityError {
CreateCloudFrontOriginAccessIdentityError::HttpDispatch(err)
}
}
impl From<io::Error> for CreateCloudFrontOriginAccessIdentityError {
fn from(err: io::Error) -> CreateCloudFrontOriginAccessIdentityError {
CreateCloudFrontOriginAccessIdentityError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CreateCloudFrontOriginAccessIdentityError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateCloudFrontOriginAccessIdentityError {
fn description(&self) -> &str {
match *self {
CreateCloudFrontOriginAccessIdentityError::CloudFrontOriginAccessIdentityAlreadyExists(ref cause) => cause,
CreateCloudFrontOriginAccessIdentityError::InconsistentQuantities(ref cause) => cause,
CreateCloudFrontOriginAccessIdentityError::InvalidArgument(ref cause) => cause,
CreateCloudFrontOriginAccessIdentityError::MissingBody(ref cause) => cause,
CreateCloudFrontOriginAccessIdentityError::TooManyCloudFrontOriginAccessIdentities(ref cause) => cause,
CreateCloudFrontOriginAccessIdentityError::Validation(ref cause) => cause,
CreateCloudFrontOriginAccessIdentityError::Credentials(ref err) => err.description(),
CreateCloudFrontOriginAccessIdentityError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
CreateCloudFrontOriginAccessIdentityError::ParseError(ref cause) => cause,
CreateCloudFrontOriginAccessIdentityError::Unknown(_) => "unknown error"
}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateDistributionError {
AccessDenied(String),
CNAMEAlreadyExists(String),
DistributionAlreadyExists(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),
NoSuchOrigin(String),
TooManyCacheBehaviors(String),
TooManyCertificates(String),
TooManyCookieNamesInWhiteList(String),
TooManyDistributionCNAMEs(String),
TooManyDistributions(String),
TooManyDistributionsWithLambdaAssociations(String),
TooManyHeadersInForwardedValues(String),
TooManyLambdaFunctionAssociations(String),
TooManyOriginCustomHeaders(String),
TooManyOrigins(String),
TooManyQueryStringParameters(String),
TooManyTrustedSigners(String),
TrustedSignerDoesNotExist(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CreateDistributionError {
pub fn from_response(res: BufferedHttpResponse) -> CreateDistributionError {
{
let reader = EventReader::new(res.body.as_slice());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"AccessDenied" => {
return CreateDistributionError::AccessDenied(String::from(
parsed_error.message,
));
}
"CNAMEAlreadyExists" => {
return CreateDistributionError::CNAMEAlreadyExists(String::from(
parsed_error.message,
));
}
"DistributionAlreadyExists" => {
return CreateDistributionError::DistributionAlreadyExists(String::from(
parsed_error.message,
));
}
"InconsistentQuantities" => {
return CreateDistributionError::InconsistentQuantities(String::from(
parsed_error.message,
));
}
"InvalidArgument" => {
return CreateDistributionError::InvalidArgument(String::from(
parsed_error.message,
));
}
"InvalidDefaultRootObject" => {
return CreateDistributionError::InvalidDefaultRootObject(String::from(
parsed_error.message,
));
}
"InvalidErrorCode" => {
return CreateDistributionError::InvalidErrorCode(String::from(
parsed_error.message,
));
}
"InvalidForwardCookies" => {
return CreateDistributionError::InvalidForwardCookies(String::from(
parsed_error.message,
));
}
"InvalidGeoRestrictionParameter" => {
return CreateDistributionError::InvalidGeoRestrictionParameter(
String::from(parsed_error.message),
);
}
"InvalidHeadersForS3Origin" => {
return CreateDistributionError::InvalidHeadersForS3Origin(String::from(
parsed_error.message,
));
}
"InvalidLambdaFunctionAssociation" => {
return CreateDistributionError::InvalidLambdaFunctionAssociation(
String::from(parsed_error.message),
);
}
"InvalidLocationCode" => {
return CreateDistributionError::InvalidLocationCode(String::from(
parsed_error.message,
));
}
"InvalidMinimumProtocolVersion" => {
return CreateDistributionError::InvalidMinimumProtocolVersion(String::from(
parsed_error.message,
));
}
"InvalidOrigin" => {
return CreateDistributionError::InvalidOrigin(String::from(
parsed_error.message,
));
}
"InvalidOriginAccessIdentity" => {
return CreateDistributionError::InvalidOriginAccessIdentity(String::from(
parsed_error.message,
));
}
"InvalidOriginKeepaliveTimeout" => {
return CreateDistributionError::InvalidOriginKeepaliveTimeout(String::from(
parsed_error.message,
));
}
"InvalidOriginReadTimeout" => {
return CreateDistributionError::InvalidOriginReadTimeout(String::from(
parsed_error.message,
));
}
"InvalidProtocolSettings" => {
return CreateDistributionError::InvalidProtocolSettings(String::from(
parsed_error.message,
));
}
"InvalidQueryStringParameters" => {
return CreateDistributionError::InvalidQueryStringParameters(String::from(
parsed_error.message,
));
}
"InvalidRelativePath" => {
return CreateDistributionError::InvalidRelativePath(String::from(
parsed_error.message,
));
}
"InvalidRequiredProtocol" => {
return CreateDistributionError::InvalidRequiredProtocol(String::from(
parsed_error.message,
));
}
"InvalidResponseCode" => {
return CreateDistributionError::InvalidResponseCode(String::from(
parsed_error.message,
));
}
"InvalidTTLOrder" => {
return CreateDistributionError::InvalidTTLOrder(String::from(
parsed_error.message,
));
}
"InvalidViewerCertificate" => {
return CreateDistributionError::InvalidViewerCertificate(String::from(
parsed_error.message,
));
}
"InvalidWebACLId" => {
return CreateDistributionError::InvalidWebACLId(String::from(
parsed_error.message,
));
}
"MissingBody" => {
return CreateDistributionError::MissingBody(String::from(
parsed_error.message,
));
}
"NoSuchOrigin" => {
return CreateDistributionError::NoSuchOrigin(String::from(
parsed_error.message,
));
}
"TooManyCacheBehaviors" => {
return CreateDistributionError::TooManyCacheBehaviors(String::from(
parsed_error.message,
));
}
"TooManyCertificates" => {
return CreateDistributionError::TooManyCertificates(String::from(
parsed_error.message,
));
}
"TooManyCookieNamesInWhiteList" => {
return CreateDistributionError::TooManyCookieNamesInWhiteList(String::from(
parsed_error.message,
));
}
"TooManyDistributionCNAMEs" => {
return CreateDistributionError::TooManyDistributionCNAMEs(String::from(
parsed_error.message,
));
}
"TooManyDistributions" => {
return CreateDistributionError::TooManyDistributions(String::from(
parsed_error.message,
));
}
"TooManyDistributionsWithLambdaAssociations" => {
return CreateDistributionError::TooManyDistributionsWithLambdaAssociations(
String::from(parsed_error.message),
);
}
"TooManyHeadersInForwardedValues" => {
return CreateDistributionError::TooManyHeadersInForwardedValues(
String::from(parsed_error.message),
);
}
"TooManyLambdaFunctionAssociations" => {
return CreateDistributionError::TooManyLambdaFunctionAssociations(
String::from(parsed_error.message),
);
}
"TooManyOriginCustomHeaders" => {
return CreateDistributionError::TooManyOriginCustomHeaders(String::from(
parsed_error.message,
));
}
"TooManyOrigins" => {
return CreateDistributionError::TooManyOrigins(String::from(
parsed_error.message,
));
}
"TooManyQueryStringParameters" => {
return CreateDistributionError::TooManyQueryStringParameters(String::from(
parsed_error.message,
));
}
"TooManyTrustedSigners" => {
return CreateDistributionError::TooManyTrustedSigners(String::from(
parsed_error.message,
));
}
"TrustedSignerDoesNotExist" => {
return CreateDistributionError::TrustedSignerDoesNotExist(String::from(
parsed_error.message,
));
}
_ => {}
}
}
}
CreateDistributionError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for CreateDistributionError {
fn from(err: XmlParseError) -> CreateDistributionError {
let XmlParseError(message) = err;
CreateDistributionError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for CreateDistributionError {
fn from(err: CredentialsError) -> CreateDistributionError {
CreateDistributionError::Credentials(err)
}
}
impl From<HttpDispatchError> for CreateDistributionError {
fn from(err: HttpDispatchError) -> CreateDistributionError {
CreateDistributionError::HttpDispatch(err)
}
}
impl From<io::Error> for CreateDistributionError {
fn from(err: io::Error) -> CreateDistributionError {
CreateDistributionError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CreateDistributionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateDistributionError {
fn description(&self) -> &str {
match *self {
CreateDistributionError::AccessDenied(ref cause) => cause,
CreateDistributionError::CNAMEAlreadyExists(ref cause) => cause,
CreateDistributionError::DistributionAlreadyExists(ref cause) => cause,
CreateDistributionError::InconsistentQuantities(ref cause) => cause,
CreateDistributionError::InvalidArgument(ref cause) => cause,
CreateDistributionError::InvalidDefaultRootObject(ref cause) => cause,
CreateDistributionError::InvalidErrorCode(ref cause) => cause,
CreateDistributionError::InvalidForwardCookies(ref cause) => cause,
CreateDistributionError::InvalidGeoRestrictionParameter(ref cause) => cause,
CreateDistributionError::InvalidHeadersForS3Origin(ref cause) => cause,
CreateDistributionError::InvalidLambdaFunctionAssociation(ref cause) => cause,
CreateDistributionError::InvalidLocationCode(ref cause) => cause,
CreateDistributionError::InvalidMinimumProtocolVersion(ref cause) => cause,
CreateDistributionError::InvalidOrigin(ref cause) => cause,
CreateDistributionError::InvalidOriginAccessIdentity(ref cause) => cause,
CreateDistributionError::InvalidOriginKeepaliveTimeout(ref cause) => cause,
CreateDistributionError::InvalidOriginReadTimeout(ref cause) => cause,
CreateDistributionError::InvalidProtocolSettings(ref cause) => cause,
CreateDistributionError::InvalidQueryStringParameters(ref cause) => cause,
CreateDistributionError::InvalidRelativePath(ref cause) => cause,
CreateDistributionError::InvalidRequiredProtocol(ref cause) => cause,
CreateDistributionError::InvalidResponseCode(ref cause) => cause,
CreateDistributionError::InvalidTTLOrder(ref cause) => cause,
CreateDistributionError::InvalidViewerCertificate(ref cause) => cause,
CreateDistributionError::InvalidWebACLId(ref cause) => cause,
CreateDistributionError::MissingBody(ref cause) => cause,
CreateDistributionError::NoSuchOrigin(ref cause) => cause,
CreateDistributionError::TooManyCacheBehaviors(ref cause) => cause,
CreateDistributionError::TooManyCertificates(ref cause) => cause,
CreateDistributionError::TooManyCookieNamesInWhiteList(ref cause) => cause,
CreateDistributionError::TooManyDistributionCNAMEs(ref cause) => cause,
CreateDistributionError::TooManyDistributions(ref cause) => cause,
CreateDistributionError::TooManyDistributionsWithLambdaAssociations(ref cause) => cause,
CreateDistributionError::TooManyHeadersInForwardedValues(ref cause) => cause,
CreateDistributionError::TooManyLambdaFunctionAssociations(ref cause) => cause,
CreateDistributionError::TooManyOriginCustomHeaders(ref cause) => cause,
CreateDistributionError::TooManyOrigins(ref cause) => cause,
CreateDistributionError::TooManyQueryStringParameters(ref cause) => cause,
CreateDistributionError::TooManyTrustedSigners(ref cause) => cause,
CreateDistributionError::TrustedSignerDoesNotExist(ref cause) => cause,
CreateDistributionError::Validation(ref cause) => cause,
CreateDistributionError::Credentials(ref err) => err.description(),
CreateDistributionError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
CreateDistributionError::ParseError(ref cause) => cause,
CreateDistributionError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateDistributionWithTagsError {
AccessDenied(String),
CNAMEAlreadyExists(String),
DistributionAlreadyExists(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),
NoSuchOrigin(String),
TooManyCacheBehaviors(String),
TooManyCertificates(String),
TooManyCookieNamesInWhiteList(String),
TooManyDistributionCNAMEs(String),
TooManyDistributions(String),
TooManyDistributionsWithLambdaAssociations(String),
TooManyHeadersInForwardedValues(String),
TooManyLambdaFunctionAssociations(String),
TooManyOriginCustomHeaders(String),
TooManyOrigins(String),
TooManyQueryStringParameters(String),
TooManyTrustedSigners(String),
TrustedSignerDoesNotExist(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CreateDistributionWithTagsError {
pub fn from_response(res: BufferedHttpResponse) -> CreateDistributionWithTagsError {
{
let reader = EventReader::new(res.body.as_slice());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"AccessDenied" => return CreateDistributionWithTagsError::AccessDenied(String::from(parsed_error.message)),"CNAMEAlreadyExists" => return CreateDistributionWithTagsError::CNAMEAlreadyExists(String::from(parsed_error.message)),"DistributionAlreadyExists" => return CreateDistributionWithTagsError::DistributionAlreadyExists(String::from(parsed_error.message)),"InconsistentQuantities" => return CreateDistributionWithTagsError::InconsistentQuantities(String::from(parsed_error.message)),"InvalidArgument" => return CreateDistributionWithTagsError::InvalidArgument(String::from(parsed_error.message)),"InvalidDefaultRootObject" => return CreateDistributionWithTagsError::InvalidDefaultRootObject(String::from(parsed_error.message)),"InvalidErrorCode" => return CreateDistributionWithTagsError::InvalidErrorCode(String::from(parsed_error.message)),"InvalidForwardCookies" => return CreateDistributionWithTagsError::InvalidForwardCookies(String::from(parsed_error.message)),"InvalidGeoRestrictionParameter" => return CreateDistributionWithTagsError::InvalidGeoRestrictionParameter(String::from(parsed_error.message)),"InvalidHeadersForS3Origin" => return CreateDistributionWithTagsError::InvalidHeadersForS3Origin(String::from(parsed_error.message)),"InvalidLambdaFunctionAssociation" => return CreateDistributionWithTagsError::InvalidLambdaFunctionAssociation(String::from(parsed_error.message)),"InvalidLocationCode" => return CreateDistributionWithTagsError::InvalidLocationCode(String::from(parsed_error.message)),"InvalidMinimumProtocolVersion" => return CreateDistributionWithTagsError::InvalidMinimumProtocolVersion(String::from(parsed_error.message)),"InvalidOrigin" => return CreateDistributionWithTagsError::InvalidOrigin(String::from(parsed_error.message)),"InvalidOriginAccessIdentity" => return CreateDistributionWithTagsError::InvalidOriginAccessIdentity(String::from(parsed_error.message)),"InvalidOriginKeepaliveTimeout" => return CreateDistributionWithTagsError::InvalidOriginKeepaliveTimeout(String::from(parsed_error.message)),"InvalidOriginReadTimeout" => return CreateDistributionWithTagsError::InvalidOriginReadTimeout(String::from(parsed_error.message)),"InvalidProtocolSettings" => return CreateDistributionWithTagsError::InvalidProtocolSettings(String::from(parsed_error.message)),"InvalidQueryStringParameters" => return CreateDistributionWithTagsError::InvalidQueryStringParameters(String::from(parsed_error.message)),"InvalidRelativePath" => return CreateDistributionWithTagsError::InvalidRelativePath(String::from(parsed_error.message)),"InvalidRequiredProtocol" => return CreateDistributionWithTagsError::InvalidRequiredProtocol(String::from(parsed_error.message)),"InvalidResponseCode" => return CreateDistributionWithTagsError::InvalidResponseCode(String::from(parsed_error.message)),"InvalidTTLOrder" => return CreateDistributionWithTagsError::InvalidTTLOrder(String::from(parsed_error.message)),"InvalidTagging" => return CreateDistributionWithTagsError::InvalidTagging(String::from(parsed_error.message)),"InvalidViewerCertificate" => return CreateDistributionWithTagsError::InvalidViewerCertificate(String::from(parsed_error.message)),"InvalidWebACLId" => return CreateDistributionWithTagsError::InvalidWebACLId(String::from(parsed_error.message)),"MissingBody" => return CreateDistributionWithTagsError::MissingBody(String::from(parsed_error.message)),"NoSuchOrigin" => return CreateDistributionWithTagsError::NoSuchOrigin(String::from(parsed_error.message)),"TooManyCacheBehaviors" => return CreateDistributionWithTagsError::TooManyCacheBehaviors(String::from(parsed_error.message)),"TooManyCertificates" => return CreateDistributionWithTagsError::TooManyCertificates(String::from(parsed_error.message)),"TooManyCookieNamesInWhiteList" => return CreateDistributionWithTagsError::TooManyCookieNamesInWhiteList(String::from(parsed_error.message)),"TooManyDistributionCNAMEs" => return CreateDistributionWithTagsError::TooManyDistributionCNAMEs(String::from(parsed_error.message)),"TooManyDistributions" => return CreateDistributionWithTagsError::TooManyDistributions(String::from(parsed_error.message)),"TooManyDistributionsWithLambdaAssociations" => return CreateDistributionWithTagsError::TooManyDistributionsWithLambdaAssociations(String::from(parsed_error.message)),"TooManyHeadersInForwardedValues" => return CreateDistributionWithTagsError::TooManyHeadersInForwardedValues(String::from(parsed_error.message)),"TooManyLambdaFunctionAssociations" => return CreateDistributionWithTagsError::TooManyLambdaFunctionAssociations(String::from(parsed_error.message)),"TooManyOriginCustomHeaders" => return CreateDistributionWithTagsError::TooManyOriginCustomHeaders(String::from(parsed_error.message)),"TooManyOrigins" => return CreateDistributionWithTagsError::TooManyOrigins(String::from(parsed_error.message)),"TooManyQueryStringParameters" => return CreateDistributionWithTagsError::TooManyQueryStringParameters(String::from(parsed_error.message)),"TooManyTrustedSigners" => return CreateDistributionWithTagsError::TooManyTrustedSigners(String::from(parsed_error.message)),"TrustedSignerDoesNotExist" => return CreateDistributionWithTagsError::TrustedSignerDoesNotExist(String::from(parsed_error.message)),_ => {}
}
}
}
CreateDistributionWithTagsError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for CreateDistributionWithTagsError {
fn from(err: XmlParseError) -> CreateDistributionWithTagsError {
let XmlParseError(message) = err;
CreateDistributionWithTagsError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for CreateDistributionWithTagsError {
fn from(err: CredentialsError) -> CreateDistributionWithTagsError {
CreateDistributionWithTagsError::Credentials(err)
}
}
impl From<HttpDispatchError> for CreateDistributionWithTagsError {
fn from(err: HttpDispatchError) -> CreateDistributionWithTagsError {
CreateDistributionWithTagsError::HttpDispatch(err)
}
}
impl From<io::Error> for CreateDistributionWithTagsError {
fn from(err: io::Error) -> CreateDistributionWithTagsError {
CreateDistributionWithTagsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CreateDistributionWithTagsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateDistributionWithTagsError {
fn description(&self) -> &str {
match *self {
CreateDistributionWithTagsError::AccessDenied(ref cause) => cause,
CreateDistributionWithTagsError::CNAMEAlreadyExists(ref cause) => cause,
CreateDistributionWithTagsError::DistributionAlreadyExists(ref cause) => cause,
CreateDistributionWithTagsError::InconsistentQuantities(ref cause) => cause,
CreateDistributionWithTagsError::InvalidArgument(ref cause) => cause,
CreateDistributionWithTagsError::InvalidDefaultRootObject(ref cause) => cause,
CreateDistributionWithTagsError::InvalidErrorCode(ref cause) => cause,
CreateDistributionWithTagsError::InvalidForwardCookies(ref cause) => cause,
CreateDistributionWithTagsError::InvalidGeoRestrictionParameter(ref cause) => cause,
CreateDistributionWithTagsError::InvalidHeadersForS3Origin(ref cause) => cause,
CreateDistributionWithTagsError::InvalidLambdaFunctionAssociation(ref cause) => cause,
CreateDistributionWithTagsError::InvalidLocationCode(ref cause) => cause,
CreateDistributionWithTagsError::InvalidMinimumProtocolVersion(ref cause) => cause,
CreateDistributionWithTagsError::InvalidOrigin(ref cause) => cause,
CreateDistributionWithTagsError::InvalidOriginAccessIdentity(ref cause) => cause,
CreateDistributionWithTagsError::InvalidOriginKeepaliveTimeout(ref cause) => cause,
CreateDistributionWithTagsError::InvalidOriginReadTimeout(ref cause) => cause,
CreateDistributionWithTagsError::InvalidProtocolSettings(ref cause) => cause,
CreateDistributionWithTagsError::InvalidQueryStringParameters(ref cause) => cause,
CreateDistributionWithTagsError::InvalidRelativePath(ref cause) => cause,
CreateDistributionWithTagsError::InvalidRequiredProtocol(ref cause) => cause,
CreateDistributionWithTagsError::InvalidResponseCode(ref cause) => cause,
CreateDistributionWithTagsError::InvalidTTLOrder(ref cause) => cause,
CreateDistributionWithTagsError::InvalidTagging(ref cause) => cause,
CreateDistributionWithTagsError::InvalidViewerCertificate(ref cause) => cause,
CreateDistributionWithTagsError::InvalidWebACLId(ref cause) => cause,
CreateDistributionWithTagsError::MissingBody(ref cause) => cause,
CreateDistributionWithTagsError::NoSuchOrigin(ref cause) => cause,
CreateDistributionWithTagsError::TooManyCacheBehaviors(ref cause) => cause,
CreateDistributionWithTagsError::TooManyCertificates(ref cause) => cause,
CreateDistributionWithTagsError::TooManyCookieNamesInWhiteList(ref cause) => cause,
CreateDistributionWithTagsError::TooManyDistributionCNAMEs(ref cause) => cause,
CreateDistributionWithTagsError::TooManyDistributions(ref cause) => cause,
CreateDistributionWithTagsError::TooManyDistributionsWithLambdaAssociations(
ref cause,
) => cause,
CreateDistributionWithTagsError::TooManyHeadersInForwardedValues(ref cause) => cause,
CreateDistributionWithTagsError::TooManyLambdaFunctionAssociations(ref cause) => cause,
CreateDistributionWithTagsError::TooManyOriginCustomHeaders(ref cause) => cause,
CreateDistributionWithTagsError::TooManyOrigins(ref cause) => cause,
CreateDistributionWithTagsError::TooManyQueryStringParameters(ref cause) => cause,
CreateDistributionWithTagsError::TooManyTrustedSigners(ref cause) => cause,
CreateDistributionWithTagsError::TrustedSignerDoesNotExist(ref cause) => cause,
CreateDistributionWithTagsError::Validation(ref cause) => cause,
CreateDistributionWithTagsError::Credentials(ref err) => err.description(),
CreateDistributionWithTagsError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
CreateDistributionWithTagsError::ParseError(ref cause) => cause,
CreateDistributionWithTagsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateInvalidationError {
AccessDenied(String),
BatchTooLarge(String),
InconsistentQuantities(String),
InvalidArgument(String),
MissingBody(String),
NoSuchDistribution(String),
TooManyInvalidationsInProgress(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CreateInvalidationError {
pub fn from_response(res: BufferedHttpResponse) -> CreateInvalidationError {
{
let reader = EventReader::new(res.body.as_slice());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"AccessDenied" => {
return CreateInvalidationError::AccessDenied(String::from(
parsed_error.message,
));
}
"BatchTooLarge" => {
return CreateInvalidationError::BatchTooLarge(String::from(
parsed_error.message,
));
}
"InconsistentQuantities" => {
return CreateInvalidationError::InconsistentQuantities(String::from(
parsed_error.message,
));
}
"InvalidArgument" => {
return CreateInvalidationError::InvalidArgument(String::from(
parsed_error.message,
));
}
"MissingBody" => {
return CreateInvalidationError::MissingBody(String::from(
parsed_error.message,
));
}
"NoSuchDistribution" => {
return CreateInvalidationError::NoSuchDistribution(String::from(
parsed_error.message,
));
}
"TooManyInvalidationsInProgress" => {
return CreateInvalidationError::TooManyInvalidationsInProgress(
String::from(parsed_error.message),
);
}
_ => {}
}
}
}
CreateInvalidationError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for CreateInvalidationError {
fn from(err: XmlParseError) -> CreateInvalidationError {
let XmlParseError(message) = err;
CreateInvalidationError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for CreateInvalidationError {
fn from(err: CredentialsError) -> CreateInvalidationError {
CreateInvalidationError::Credentials(err)
}
}
impl From<HttpDispatchError> for CreateInvalidationError {
fn from(err: HttpDispatchError) -> CreateInvalidationError {
CreateInvalidationError::HttpDispatch(err)
}
}
impl From<io::Error> for CreateInvalidationError {
fn from(err: io::Error) -> CreateInvalidationError {
CreateInvalidationError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CreateInvalidationError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateInvalidationError {
fn description(&self) -> &str {
match *self {
CreateInvalidationError::AccessDenied(ref cause) => cause,
CreateInvalidationError::BatchTooLarge(ref cause) => cause,
CreateInvalidationError::InconsistentQuantities(ref cause) => cause,
CreateInvalidationError::InvalidArgument(ref cause) => cause,
CreateInvalidationError::MissingBody(ref cause) => cause,
CreateInvalidationError::NoSuchDistribution(ref cause) => cause,
CreateInvalidationError::TooManyInvalidationsInProgress(ref cause) => cause,
CreateInvalidationError::Validation(ref cause) => cause,
CreateInvalidationError::Credentials(ref err) => err.description(),
CreateInvalidationError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
CreateInvalidationError::ParseError(ref cause) => cause,
CreateInvalidationError::Unknown(_) => "unknown error",
}
}
}
#[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),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CreateStreamingDistributionError {
pub fn from_response(res: BufferedHttpResponse) -> CreateStreamingDistributionError {
{
let reader = EventReader::new(res.body.as_slice());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"AccessDenied" => {
return CreateStreamingDistributionError::AccessDenied(String::from(
parsed_error.message,
));
}
"CNAMEAlreadyExists" => {
return CreateStreamingDistributionError::CNAMEAlreadyExists(String::from(
parsed_error.message,
));
}
"InconsistentQuantities" => {
return CreateStreamingDistributionError::InconsistentQuantities(
String::from(parsed_error.message),
);
}
"InvalidArgument" => {
return CreateStreamingDistributionError::InvalidArgument(String::from(
parsed_error.message,
));
}
"InvalidOrigin" => {
return CreateStreamingDistributionError::InvalidOrigin(String::from(
parsed_error.message,
));
}
"InvalidOriginAccessIdentity" => {
return CreateStreamingDistributionError::InvalidOriginAccessIdentity(
String::from(parsed_error.message),
);
}
"MissingBody" => {
return CreateStreamingDistributionError::MissingBody(String::from(
parsed_error.message,
));
}
"StreamingDistributionAlreadyExists" => {
return CreateStreamingDistributionError::StreamingDistributionAlreadyExists(
String::from(parsed_error.message),
);
}
"TooManyStreamingDistributionCNAMEs" => {
return CreateStreamingDistributionError::TooManyStreamingDistributionCNAMEs(
String::from(parsed_error.message),
);
}
"TooManyStreamingDistributions" => {
return CreateStreamingDistributionError::TooManyStreamingDistributions(
String::from(parsed_error.message),
);
}
"TooManyTrustedSigners" => {
return CreateStreamingDistributionError::TooManyTrustedSigners(
String::from(parsed_error.message),
);
}
"TrustedSignerDoesNotExist" => {
return CreateStreamingDistributionError::TrustedSignerDoesNotExist(
String::from(parsed_error.message),
);
}
_ => {}
}
}
}
CreateStreamingDistributionError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for CreateStreamingDistributionError {
fn from(err: XmlParseError) -> CreateStreamingDistributionError {
let XmlParseError(message) = err;
CreateStreamingDistributionError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for CreateStreamingDistributionError {
fn from(err: CredentialsError) -> CreateStreamingDistributionError {
CreateStreamingDistributionError::Credentials(err)
}
}
impl From<HttpDispatchError> for CreateStreamingDistributionError {
fn from(err: HttpDispatchError) -> CreateStreamingDistributionError {
CreateStreamingDistributionError::HttpDispatch(err)
}
}
impl From<io::Error> for CreateStreamingDistributionError {
fn from(err: io::Error) -> CreateStreamingDistributionError {
CreateStreamingDistributionError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CreateStreamingDistributionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateStreamingDistributionError {
fn description(&self) -> &str {
match *self {
CreateStreamingDistributionError::AccessDenied(ref cause) => cause,
CreateStreamingDistributionError::CNAMEAlreadyExists(ref cause) => cause,
CreateStreamingDistributionError::InconsistentQuantities(ref cause) => cause,
CreateStreamingDistributionError::InvalidArgument(ref cause) => cause,
CreateStreamingDistributionError::InvalidOrigin(ref cause) => cause,
CreateStreamingDistributionError::InvalidOriginAccessIdentity(ref cause) => cause,
CreateStreamingDistributionError::MissingBody(ref cause) => cause,
CreateStreamingDistributionError::StreamingDistributionAlreadyExists(ref cause) => {
cause
}
CreateStreamingDistributionError::TooManyStreamingDistributionCNAMEs(ref cause) => {
cause
}
CreateStreamingDistributionError::TooManyStreamingDistributions(ref cause) => cause,
CreateStreamingDistributionError::TooManyTrustedSigners(ref cause) => cause,
CreateStreamingDistributionError::TrustedSignerDoesNotExist(ref cause) => cause,
CreateStreamingDistributionError::Validation(ref cause) => cause,
CreateStreamingDistributionError::Credentials(ref err) => err.description(),
CreateStreamingDistributionError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
CreateStreamingDistributionError::ParseError(ref cause) => cause,
CreateStreamingDistributionError::Unknown(_) => "unknown error",
}
}
}
#[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),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CreateStreamingDistributionWithTagsError {
pub fn from_response(res: BufferedHttpResponse) -> CreateStreamingDistributionWithTagsError {
{
let reader = EventReader::new(res.body.as_slice());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"AccessDenied" => return CreateStreamingDistributionWithTagsError::AccessDenied(String::from(parsed_error.message)),"CNAMEAlreadyExists" => return CreateStreamingDistributionWithTagsError::CNAMEAlreadyExists(String::from(parsed_error.message)),"InconsistentQuantities" => return CreateStreamingDistributionWithTagsError::InconsistentQuantities(String::from(parsed_error.message)),"InvalidArgument" => return CreateStreamingDistributionWithTagsError::InvalidArgument(String::from(parsed_error.message)),"InvalidOrigin" => return CreateStreamingDistributionWithTagsError::InvalidOrigin(String::from(parsed_error.message)),"InvalidOriginAccessIdentity" => return CreateStreamingDistributionWithTagsError::InvalidOriginAccessIdentity(String::from(parsed_error.message)),"InvalidTagging" => return CreateStreamingDistributionWithTagsError::InvalidTagging(String::from(parsed_error.message)),"MissingBody" => return CreateStreamingDistributionWithTagsError::MissingBody(String::from(parsed_error.message)),"StreamingDistributionAlreadyExists" => return CreateStreamingDistributionWithTagsError::StreamingDistributionAlreadyExists(String::from(parsed_error.message)),"TooManyStreamingDistributionCNAMEs" => return CreateStreamingDistributionWithTagsError::TooManyStreamingDistributionCNAMEs(String::from(parsed_error.message)),"TooManyStreamingDistributions" => return CreateStreamingDistributionWithTagsError::TooManyStreamingDistributions(String::from(parsed_error.message)),"TooManyTrustedSigners" => return CreateStreamingDistributionWithTagsError::TooManyTrustedSigners(String::from(parsed_error.message)),"TrustedSignerDoesNotExist" => return CreateStreamingDistributionWithTagsError::TrustedSignerDoesNotExist(String::from(parsed_error.message)),_ => {}
}
}
}
CreateStreamingDistributionWithTagsError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for CreateStreamingDistributionWithTagsError {
fn from(err: XmlParseError) -> CreateStreamingDistributionWithTagsError {
let XmlParseError(message) = err;
CreateStreamingDistributionWithTagsError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for CreateStreamingDistributionWithTagsError {
fn from(err: CredentialsError) -> CreateStreamingDistributionWithTagsError {
CreateStreamingDistributionWithTagsError::Credentials(err)
}
}
impl From<HttpDispatchError> for CreateStreamingDistributionWithTagsError {
fn from(err: HttpDispatchError) -> CreateStreamingDistributionWithTagsError {
CreateStreamingDistributionWithTagsError::HttpDispatch(err)
}
}
impl From<io::Error> for CreateStreamingDistributionWithTagsError {
fn from(err: io::Error) -> CreateStreamingDistributionWithTagsError {
CreateStreamingDistributionWithTagsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CreateStreamingDistributionWithTagsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateStreamingDistributionWithTagsError {
fn description(&self) -> &str {
match *self {
CreateStreamingDistributionWithTagsError::AccessDenied(ref cause) => cause,
CreateStreamingDistributionWithTagsError::CNAMEAlreadyExists(ref cause) => cause,
CreateStreamingDistributionWithTagsError::InconsistentQuantities(ref cause) => cause,
CreateStreamingDistributionWithTagsError::InvalidArgument(ref cause) => cause,
CreateStreamingDistributionWithTagsError::InvalidOrigin(ref cause) => cause,
CreateStreamingDistributionWithTagsError::InvalidOriginAccessIdentity(ref cause) => {
cause
}
CreateStreamingDistributionWithTagsError::InvalidTagging(ref cause) => cause,
CreateStreamingDistributionWithTagsError::MissingBody(ref cause) => cause,
CreateStreamingDistributionWithTagsError::StreamingDistributionAlreadyExists(
ref cause,
) => cause,
CreateStreamingDistributionWithTagsError::TooManyStreamingDistributionCNAMEs(
ref cause,
) => cause,
CreateStreamingDistributionWithTagsError::TooManyStreamingDistributions(ref cause) => {
cause
}
CreateStreamingDistributionWithTagsError::TooManyTrustedSigners(ref cause) => cause,
CreateStreamingDistributionWithTagsError::TrustedSignerDoesNotExist(ref cause) => cause,
CreateStreamingDistributionWithTagsError::Validation(ref cause) => cause,
CreateStreamingDistributionWithTagsError::Credentials(ref err) => err.description(),
CreateStreamingDistributionWithTagsError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
CreateStreamingDistributionWithTagsError::ParseError(ref cause) => cause,
CreateStreamingDistributionWithTagsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteCloudFrontOriginAccessIdentityError {
AccessDenied(String),
CloudFrontOriginAccessIdentityInUse(String),
InvalidIfMatchVersion(String),
NoSuchCloudFrontOriginAccessIdentity(String),
PreconditionFailed(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DeleteCloudFrontOriginAccessIdentityError {
pub fn from_response(res: BufferedHttpResponse) -> DeleteCloudFrontOriginAccessIdentityError {
{
let reader = EventReader::new(res.body.as_slice());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"AccessDenied" => return DeleteCloudFrontOriginAccessIdentityError::AccessDenied(String::from(parsed_error.message)),"CloudFrontOriginAccessIdentityInUse" => return DeleteCloudFrontOriginAccessIdentityError::CloudFrontOriginAccessIdentityInUse(String::from(parsed_error.message)),"InvalidIfMatchVersion" => return DeleteCloudFrontOriginAccessIdentityError::InvalidIfMatchVersion(String::from(parsed_error.message)),"NoSuchCloudFrontOriginAccessIdentity" => return DeleteCloudFrontOriginAccessIdentityError::NoSuchCloudFrontOriginAccessIdentity(String::from(parsed_error.message)),"PreconditionFailed" => return DeleteCloudFrontOriginAccessIdentityError::PreconditionFailed(String::from(parsed_error.message)),_ => {}
}
}
}
DeleteCloudFrontOriginAccessIdentityError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for DeleteCloudFrontOriginAccessIdentityError {
fn from(err: XmlParseError) -> DeleteCloudFrontOriginAccessIdentityError {
let XmlParseError(message) = err;
DeleteCloudFrontOriginAccessIdentityError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DeleteCloudFrontOriginAccessIdentityError {
fn from(err: CredentialsError) -> DeleteCloudFrontOriginAccessIdentityError {
DeleteCloudFrontOriginAccessIdentityError::Credentials(err)
}
}
impl From<HttpDispatchError> for DeleteCloudFrontOriginAccessIdentityError {
fn from(err: HttpDispatchError) -> DeleteCloudFrontOriginAccessIdentityError {
DeleteCloudFrontOriginAccessIdentityError::HttpDispatch(err)
}
}
impl From<io::Error> for DeleteCloudFrontOriginAccessIdentityError {
fn from(err: io::Error) -> DeleteCloudFrontOriginAccessIdentityError {
DeleteCloudFrontOriginAccessIdentityError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DeleteCloudFrontOriginAccessIdentityError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteCloudFrontOriginAccessIdentityError {
fn description(&self) -> &str {
match *self {
DeleteCloudFrontOriginAccessIdentityError::AccessDenied(ref cause) => cause,
DeleteCloudFrontOriginAccessIdentityError::CloudFrontOriginAccessIdentityInUse(
ref cause,
) => cause,
DeleteCloudFrontOriginAccessIdentityError::InvalidIfMatchVersion(ref cause) => cause,
DeleteCloudFrontOriginAccessIdentityError::NoSuchCloudFrontOriginAccessIdentity(
ref cause,
) => cause,
DeleteCloudFrontOriginAccessIdentityError::PreconditionFailed(ref cause) => cause,
DeleteCloudFrontOriginAccessIdentityError::Validation(ref cause) => cause,
DeleteCloudFrontOriginAccessIdentityError::Credentials(ref err) => err.description(),
DeleteCloudFrontOriginAccessIdentityError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DeleteCloudFrontOriginAccessIdentityError::ParseError(ref cause) => cause,
DeleteCloudFrontOriginAccessIdentityError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteDistributionError {
AccessDenied(String),
DistributionNotDisabled(String),
InvalidIfMatchVersion(String),
NoSuchDistribution(String),
PreconditionFailed(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DeleteDistributionError {
pub fn from_response(res: BufferedHttpResponse) -> DeleteDistributionError {
{
let reader = EventReader::new(res.body.as_slice());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"AccessDenied" => {
return DeleteDistributionError::AccessDenied(String::from(
parsed_error.message,
));
}
"DistributionNotDisabled" => {
return DeleteDistributionError::DistributionNotDisabled(String::from(
parsed_error.message,
));
}
"InvalidIfMatchVersion" => {
return DeleteDistributionError::InvalidIfMatchVersion(String::from(
parsed_error.message,
));
}
"NoSuchDistribution" => {
return DeleteDistributionError::NoSuchDistribution(String::from(
parsed_error.message,
));
}
"PreconditionFailed" => {
return DeleteDistributionError::PreconditionFailed(String::from(
parsed_error.message,
));
}
_ => {}
}
}
}
DeleteDistributionError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for DeleteDistributionError {
fn from(err: XmlParseError) -> DeleteDistributionError {
let XmlParseError(message) = err;
DeleteDistributionError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DeleteDistributionError {
fn from(err: CredentialsError) -> DeleteDistributionError {
DeleteDistributionError::Credentials(err)
}
}
impl From<HttpDispatchError> for DeleteDistributionError {
fn from(err: HttpDispatchError) -> DeleteDistributionError {
DeleteDistributionError::HttpDispatch(err)
}
}
impl From<io::Error> for DeleteDistributionError {
fn from(err: io::Error) -> DeleteDistributionError {
DeleteDistributionError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DeleteDistributionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteDistributionError {
fn description(&self) -> &str {
match *self {
DeleteDistributionError::AccessDenied(ref cause) => cause,
DeleteDistributionError::DistributionNotDisabled(ref cause) => cause,
DeleteDistributionError::InvalidIfMatchVersion(ref cause) => cause,
DeleteDistributionError::NoSuchDistribution(ref cause) => cause,
DeleteDistributionError::PreconditionFailed(ref cause) => cause,
DeleteDistributionError::Validation(ref cause) => cause,
DeleteDistributionError::Credentials(ref err) => err.description(),
DeleteDistributionError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DeleteDistributionError::ParseError(ref cause) => cause,
DeleteDistributionError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteServiceLinkedRoleError {
AccessDenied(String),
InvalidArgument(String),
NoSuchResource(String),
ResourceInUse(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DeleteServiceLinkedRoleError {
pub fn from_response(res: BufferedHttpResponse) -> DeleteServiceLinkedRoleError {
{
let reader = EventReader::new(res.body.as_slice());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"AccessDenied" => {
return DeleteServiceLinkedRoleError::AccessDenied(String::from(
parsed_error.message,
));
}
"InvalidArgument" => {
return DeleteServiceLinkedRoleError::InvalidArgument(String::from(
parsed_error.message,
));
}
"NoSuchResource" => {
return DeleteServiceLinkedRoleError::NoSuchResource(String::from(
parsed_error.message,
));
}
"ResourceInUse" => {
return DeleteServiceLinkedRoleError::ResourceInUse(String::from(
parsed_error.message,
));
}
_ => {}
}
}
}
DeleteServiceLinkedRoleError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for DeleteServiceLinkedRoleError {
fn from(err: XmlParseError) -> DeleteServiceLinkedRoleError {
let XmlParseError(message) = err;
DeleteServiceLinkedRoleError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DeleteServiceLinkedRoleError {
fn from(err: CredentialsError) -> DeleteServiceLinkedRoleError {
DeleteServiceLinkedRoleError::Credentials(err)
}
}
impl From<HttpDispatchError> for DeleteServiceLinkedRoleError {
fn from(err: HttpDispatchError) -> DeleteServiceLinkedRoleError {
DeleteServiceLinkedRoleError::HttpDispatch(err)
}
}
impl From<io::Error> for DeleteServiceLinkedRoleError {
fn from(err: io::Error) -> DeleteServiceLinkedRoleError {
DeleteServiceLinkedRoleError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DeleteServiceLinkedRoleError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteServiceLinkedRoleError {
fn description(&self) -> &str {
match *self {
DeleteServiceLinkedRoleError::AccessDenied(ref cause) => cause,
DeleteServiceLinkedRoleError::InvalidArgument(ref cause) => cause,
DeleteServiceLinkedRoleError::NoSuchResource(ref cause) => cause,
DeleteServiceLinkedRoleError::ResourceInUse(ref cause) => cause,
DeleteServiceLinkedRoleError::Validation(ref cause) => cause,
DeleteServiceLinkedRoleError::Credentials(ref err) => err.description(),
DeleteServiceLinkedRoleError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DeleteServiceLinkedRoleError::ParseError(ref cause) => cause,
DeleteServiceLinkedRoleError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteStreamingDistributionError {
AccessDenied(String),
InvalidIfMatchVersion(String),
NoSuchStreamingDistribution(String),
PreconditionFailed(String),
StreamingDistributionNotDisabled(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DeleteStreamingDistributionError {
pub fn from_response(res: BufferedHttpResponse) -> DeleteStreamingDistributionError {
{
let reader = EventReader::new(res.body.as_slice());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"AccessDenied" => {
return DeleteStreamingDistributionError::AccessDenied(String::from(
parsed_error.message,
));
}
"InvalidIfMatchVersion" => {
return DeleteStreamingDistributionError::InvalidIfMatchVersion(
String::from(parsed_error.message),
);
}
"NoSuchStreamingDistribution" => {
return DeleteStreamingDistributionError::NoSuchStreamingDistribution(
String::from(parsed_error.message),
);
}
"PreconditionFailed" => {
return DeleteStreamingDistributionError::PreconditionFailed(String::from(
parsed_error.message,
));
}
"StreamingDistributionNotDisabled" => {
return DeleteStreamingDistributionError::StreamingDistributionNotDisabled(
String::from(parsed_error.message),
);
}
_ => {}
}
}
}
DeleteStreamingDistributionError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for DeleteStreamingDistributionError {
fn from(err: XmlParseError) -> DeleteStreamingDistributionError {
let XmlParseError(message) = err;
DeleteStreamingDistributionError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for DeleteStreamingDistributionError {
fn from(err: CredentialsError) -> DeleteStreamingDistributionError {
DeleteStreamingDistributionError::Credentials(err)
}
}
impl From<HttpDispatchError> for DeleteStreamingDistributionError {
fn from(err: HttpDispatchError) -> DeleteStreamingDistributionError {
DeleteStreamingDistributionError::HttpDispatch(err)
}
}
impl From<io::Error> for DeleteStreamingDistributionError {
fn from(err: io::Error) -> DeleteStreamingDistributionError {
DeleteStreamingDistributionError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DeleteStreamingDistributionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteStreamingDistributionError {
fn description(&self) -> &str {
match *self {
DeleteStreamingDistributionError::AccessDenied(ref cause) => cause,
DeleteStreamingDistributionError::InvalidIfMatchVersion(ref cause) => cause,
DeleteStreamingDistributionError::NoSuchStreamingDistribution(ref cause) => cause,
DeleteStreamingDistributionError::PreconditionFailed(ref cause) => cause,
DeleteStreamingDistributionError::StreamingDistributionNotDisabled(ref cause) => cause,
DeleteStreamingDistributionError::Validation(ref cause) => cause,
DeleteStreamingDistributionError::Credentials(ref err) => err.description(),
DeleteStreamingDistributionError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DeleteStreamingDistributionError::ParseError(ref cause) => cause,
DeleteStreamingDistributionError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum GetCloudFrontOriginAccessIdentityError {
AccessDenied(String),
NoSuchCloudFrontOriginAccessIdentity(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl GetCloudFrontOriginAccessIdentityError {
pub fn from_response(res: BufferedHttpResponse) -> GetCloudFrontOriginAccessIdentityError {
{
let reader = EventReader::new(res.body.as_slice());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"AccessDenied" => return GetCloudFrontOriginAccessIdentityError::AccessDenied(String::from(parsed_error.message)),"NoSuchCloudFrontOriginAccessIdentity" => return GetCloudFrontOriginAccessIdentityError::NoSuchCloudFrontOriginAccessIdentity(String::from(parsed_error.message)),_ => {}
}
}
}
GetCloudFrontOriginAccessIdentityError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for GetCloudFrontOriginAccessIdentityError {
fn from(err: XmlParseError) -> GetCloudFrontOriginAccessIdentityError {
let XmlParseError(message) = err;
GetCloudFrontOriginAccessIdentityError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for GetCloudFrontOriginAccessIdentityError {
fn from(err: CredentialsError) -> GetCloudFrontOriginAccessIdentityError {
GetCloudFrontOriginAccessIdentityError::Credentials(err)
}
}
impl From<HttpDispatchError> for GetCloudFrontOriginAccessIdentityError {
fn from(err: HttpDispatchError) -> GetCloudFrontOriginAccessIdentityError {
GetCloudFrontOriginAccessIdentityError::HttpDispatch(err)
}
}
impl From<io::Error> for GetCloudFrontOriginAccessIdentityError {
fn from(err: io::Error) -> GetCloudFrontOriginAccessIdentityError {
GetCloudFrontOriginAccessIdentityError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for GetCloudFrontOriginAccessIdentityError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetCloudFrontOriginAccessIdentityError {
fn description(&self) -> &str {
match *self {
GetCloudFrontOriginAccessIdentityError::AccessDenied(ref cause) => cause,
GetCloudFrontOriginAccessIdentityError::NoSuchCloudFrontOriginAccessIdentity(
ref cause,
) => cause,
GetCloudFrontOriginAccessIdentityError::Validation(ref cause) => cause,
GetCloudFrontOriginAccessIdentityError::Credentials(ref err) => err.description(),
GetCloudFrontOriginAccessIdentityError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
GetCloudFrontOriginAccessIdentityError::ParseError(ref cause) => cause,
GetCloudFrontOriginAccessIdentityError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum GetCloudFrontOriginAccessIdentityConfigError {
AccessDenied(String),
NoSuchCloudFrontOriginAccessIdentity(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl GetCloudFrontOriginAccessIdentityConfigError {
pub fn from_response(
res: BufferedHttpResponse,
) -> GetCloudFrontOriginAccessIdentityConfigError {
{
let reader = EventReader::new(res.body.as_slice());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"AccessDenied" => return GetCloudFrontOriginAccessIdentityConfigError::AccessDenied(String::from(parsed_error.message)),"NoSuchCloudFrontOriginAccessIdentity" => return GetCloudFrontOriginAccessIdentityConfigError::NoSuchCloudFrontOriginAccessIdentity(String::from(parsed_error.message)),_ => {}
}
}
}
GetCloudFrontOriginAccessIdentityConfigError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for GetCloudFrontOriginAccessIdentityConfigError {
fn from(err: XmlParseError) -> GetCloudFrontOriginAccessIdentityConfigError {
let XmlParseError(message) = err;
GetCloudFrontOriginAccessIdentityConfigError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for GetCloudFrontOriginAccessIdentityConfigError {
fn from(err: CredentialsError) -> GetCloudFrontOriginAccessIdentityConfigError {
GetCloudFrontOriginAccessIdentityConfigError::Credentials(err)
}
}
impl From<HttpDispatchError> for GetCloudFrontOriginAccessIdentityConfigError {
fn from(err: HttpDispatchError) -> GetCloudFrontOriginAccessIdentityConfigError {
GetCloudFrontOriginAccessIdentityConfigError::HttpDispatch(err)
}
}
impl From<io::Error> for GetCloudFrontOriginAccessIdentityConfigError {
fn from(err: io::Error) -> GetCloudFrontOriginAccessIdentityConfigError {
GetCloudFrontOriginAccessIdentityConfigError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for GetCloudFrontOriginAccessIdentityConfigError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetCloudFrontOriginAccessIdentityConfigError {
fn description(&self) -> &str {
match *self {
GetCloudFrontOriginAccessIdentityConfigError::AccessDenied(ref cause) => cause,
GetCloudFrontOriginAccessIdentityConfigError::NoSuchCloudFrontOriginAccessIdentity(
ref cause,
) => cause,
GetCloudFrontOriginAccessIdentityConfigError::Validation(ref cause) => cause,
GetCloudFrontOriginAccessIdentityConfigError::Credentials(ref err) => err.description(),
GetCloudFrontOriginAccessIdentityConfigError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
GetCloudFrontOriginAccessIdentityConfigError::ParseError(ref cause) => cause,
GetCloudFrontOriginAccessIdentityConfigError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum GetDistributionError {
AccessDenied(String),
NoSuchDistribution(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl GetDistributionError {
pub fn from_response(res: BufferedHttpResponse) -> GetDistributionError {
{
let reader = EventReader::new(res.body.as_slice());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"AccessDenied" => {
return GetDistributionError::AccessDenied(String::from(
parsed_error.message,
));
}
"NoSuchDistribution" => {
return GetDistributionError::NoSuchDistribution(String::from(
parsed_error.message,
));
}
_ => {}
}
}
}
GetDistributionError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for GetDistributionError {
fn from(err: XmlParseError) -> GetDistributionError {
let XmlParseError(message) = err;
GetDistributionError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for GetDistributionError {
fn from(err: CredentialsError) -> GetDistributionError {
GetDistributionError::Credentials(err)
}
}
impl From<HttpDispatchError> for GetDistributionError {
fn from(err: HttpDispatchError) -> GetDistributionError {
GetDistributionError::HttpDispatch(err)
}
}
impl From<io::Error> for GetDistributionError {
fn from(err: io::Error) -> GetDistributionError {
GetDistributionError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for GetDistributionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetDistributionError {
fn description(&self) -> &str {
match *self {
GetDistributionError::AccessDenied(ref cause) => cause,
GetDistributionError::NoSuchDistribution(ref cause) => cause,
GetDistributionError::Validation(ref cause) => cause,
GetDistributionError::Credentials(ref err) => err.description(),
GetDistributionError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
GetDistributionError::ParseError(ref cause) => cause,
GetDistributionError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum GetDistributionConfigError {
AccessDenied(String),
NoSuchDistribution(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl GetDistributionConfigError {
pub fn from_response(res: BufferedHttpResponse) -> GetDistributionConfigError {
{
let reader = EventReader::new(res.body.as_slice());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"AccessDenied" => {
return GetDistributionConfigError::AccessDenied(String::from(
parsed_error.message,
));
}
"NoSuchDistribution" => {
return GetDistributionConfigError::NoSuchDistribution(String::from(
parsed_error.message,
));
}
_ => {}
}
}
}
GetDistributionConfigError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for GetDistributionConfigError {
fn from(err: XmlParseError) -> GetDistributionConfigError {
let XmlParseError(message) = err;
GetDistributionConfigError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for GetDistributionConfigError {
fn from(err: CredentialsError) -> GetDistributionConfigError {
GetDistributionConfigError::Credentials(err)
}
}
impl From<HttpDispatchError> for GetDistributionConfigError {
fn from(err: HttpDispatchError) -> GetDistributionConfigError {
GetDistributionConfigError::HttpDispatch(err)
}
}
impl From<io::Error> for GetDistributionConfigError {
fn from(err: io::Error) -> GetDistributionConfigError {
GetDistributionConfigError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for GetDistributionConfigError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetDistributionConfigError {
fn description(&self) -> &str {
match *self {
GetDistributionConfigError::AccessDenied(ref cause) => cause,
GetDistributionConfigError::NoSuchDistribution(ref cause) => cause,
GetDistributionConfigError::Validation(ref cause) => cause,
GetDistributionConfigError::Credentials(ref err) => err.description(),
GetDistributionConfigError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
GetDistributionConfigError::ParseError(ref cause) => cause,
GetDistributionConfigError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum GetInvalidationError {
AccessDenied(String),
NoSuchDistribution(String),
NoSuchInvalidation(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl GetInvalidationError {
pub fn from_response(res: BufferedHttpResponse) -> GetInvalidationError {
{
let reader = EventReader::new(res.body.as_slice());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"AccessDenied" => {
return GetInvalidationError::AccessDenied(String::from(
parsed_error.message,
));
}
"NoSuchDistribution" => {
return GetInvalidationError::NoSuchDistribution(String::from(
parsed_error.message,
));
}
"NoSuchInvalidation" => {
return GetInvalidationError::NoSuchInvalidation(String::from(
parsed_error.message,
));
}
_ => {}
}
}
}
GetInvalidationError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for GetInvalidationError {
fn from(err: XmlParseError) -> GetInvalidationError {
let XmlParseError(message) = err;
GetInvalidationError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for GetInvalidationError {
fn from(err: CredentialsError) -> GetInvalidationError {
GetInvalidationError::Credentials(err)
}
}
impl From<HttpDispatchError> for GetInvalidationError {
fn from(err: HttpDispatchError) -> GetInvalidationError {
GetInvalidationError::HttpDispatch(err)
}
}
impl From<io::Error> for GetInvalidationError {
fn from(err: io::Error) -> GetInvalidationError {
GetInvalidationError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for GetInvalidationError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetInvalidationError {
fn description(&self) -> &str {
match *self {
GetInvalidationError::AccessDenied(ref cause) => cause,
GetInvalidationError::NoSuchDistribution(ref cause) => cause,
GetInvalidationError::NoSuchInvalidation(ref cause) => cause,
GetInvalidationError::Validation(ref cause) => cause,
GetInvalidationError::Credentials(ref err) => err.description(),
GetInvalidationError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
GetInvalidationError::ParseError(ref cause) => cause,
GetInvalidationError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum GetStreamingDistributionError {
AccessDenied(String),
NoSuchStreamingDistribution(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl GetStreamingDistributionError {
pub fn from_response(res: BufferedHttpResponse) -> GetStreamingDistributionError {
{
let reader = EventReader::new(res.body.as_slice());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"AccessDenied" => {
return GetStreamingDistributionError::AccessDenied(String::from(
parsed_error.message,
));
}
"NoSuchStreamingDistribution" => {
return GetStreamingDistributionError::NoSuchStreamingDistribution(
String::from(parsed_error.message),
);
}
_ => {}
}
}
}
GetStreamingDistributionError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for GetStreamingDistributionError {
fn from(err: XmlParseError) -> GetStreamingDistributionError {
let XmlParseError(message) = err;
GetStreamingDistributionError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for GetStreamingDistributionError {
fn from(err: CredentialsError) -> GetStreamingDistributionError {
GetStreamingDistributionError::Credentials(err)
}
}
impl From<HttpDispatchError> for GetStreamingDistributionError {
fn from(err: HttpDispatchError) -> GetStreamingDistributionError {
GetStreamingDistributionError::HttpDispatch(err)
}
}
impl From<io::Error> for GetStreamingDistributionError {
fn from(err: io::Error) -> GetStreamingDistributionError {
GetStreamingDistributionError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for GetStreamingDistributionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetStreamingDistributionError {
fn description(&self) -> &str {
match *self {
GetStreamingDistributionError::AccessDenied(ref cause) => cause,
GetStreamingDistributionError::NoSuchStreamingDistribution(ref cause) => cause,
GetStreamingDistributionError::Validation(ref cause) => cause,
GetStreamingDistributionError::Credentials(ref err) => err.description(),
GetStreamingDistributionError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
GetStreamingDistributionError::ParseError(ref cause) => cause,
GetStreamingDistributionError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum GetStreamingDistributionConfigError {
AccessDenied(String),
NoSuchStreamingDistribution(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl GetStreamingDistributionConfigError {
pub fn from_response(res: BufferedHttpResponse) -> GetStreamingDistributionConfigError {
{
let reader = EventReader::new(res.body.as_slice());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"AccessDenied" => {
return GetStreamingDistributionConfigError::AccessDenied(String::from(
parsed_error.message,
));
}
"NoSuchStreamingDistribution" => {
return GetStreamingDistributionConfigError::NoSuchStreamingDistribution(
String::from(parsed_error.message),
);
}
_ => {}
}
}
}
GetStreamingDistributionConfigError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for GetStreamingDistributionConfigError {
fn from(err: XmlParseError) -> GetStreamingDistributionConfigError {
let XmlParseError(message) = err;
GetStreamingDistributionConfigError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for GetStreamingDistributionConfigError {
fn from(err: CredentialsError) -> GetStreamingDistributionConfigError {
GetStreamingDistributionConfigError::Credentials(err)
}
}
impl From<HttpDispatchError> for GetStreamingDistributionConfigError {
fn from(err: HttpDispatchError) -> GetStreamingDistributionConfigError {
GetStreamingDistributionConfigError::HttpDispatch(err)
}
}
impl From<io::Error> for GetStreamingDistributionConfigError {
fn from(err: io::Error) -> GetStreamingDistributionConfigError {
GetStreamingDistributionConfigError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for GetStreamingDistributionConfigError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetStreamingDistributionConfigError {
fn description(&self) -> &str {
match *self {
GetStreamingDistributionConfigError::AccessDenied(ref cause) => cause,
GetStreamingDistributionConfigError::NoSuchStreamingDistribution(ref cause) => cause,
GetStreamingDistributionConfigError::Validation(ref cause) => cause,
GetStreamingDistributionConfigError::Credentials(ref err) => err.description(),
GetStreamingDistributionConfigError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
GetStreamingDistributionConfigError::ParseError(ref cause) => cause,
GetStreamingDistributionConfigError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ListCloudFrontOriginAccessIdentitiesError {
InvalidArgument(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ListCloudFrontOriginAccessIdentitiesError {
pub fn from_response(res: BufferedHttpResponse) -> ListCloudFrontOriginAccessIdentitiesError {
{
let reader = EventReader::new(res.body.as_slice());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"InvalidArgument" => {
return ListCloudFrontOriginAccessIdentitiesError::InvalidArgument(
String::from(parsed_error.message),
);
}
_ => {}
}
}
}
ListCloudFrontOriginAccessIdentitiesError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for ListCloudFrontOriginAccessIdentitiesError {
fn from(err: XmlParseError) -> ListCloudFrontOriginAccessIdentitiesError {
let XmlParseError(message) = err;
ListCloudFrontOriginAccessIdentitiesError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for ListCloudFrontOriginAccessIdentitiesError {
fn from(err: CredentialsError) -> ListCloudFrontOriginAccessIdentitiesError {
ListCloudFrontOriginAccessIdentitiesError::Credentials(err)
}
}
impl From<HttpDispatchError> for ListCloudFrontOriginAccessIdentitiesError {
fn from(err: HttpDispatchError) -> ListCloudFrontOriginAccessIdentitiesError {
ListCloudFrontOriginAccessIdentitiesError::HttpDispatch(err)
}
}
impl From<io::Error> for ListCloudFrontOriginAccessIdentitiesError {
fn from(err: io::Error) -> ListCloudFrontOriginAccessIdentitiesError {
ListCloudFrontOriginAccessIdentitiesError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ListCloudFrontOriginAccessIdentitiesError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ListCloudFrontOriginAccessIdentitiesError {
fn description(&self) -> &str {
match *self {
ListCloudFrontOriginAccessIdentitiesError::InvalidArgument(ref cause) => cause,
ListCloudFrontOriginAccessIdentitiesError::Validation(ref cause) => cause,
ListCloudFrontOriginAccessIdentitiesError::Credentials(ref err) => err.description(),
ListCloudFrontOriginAccessIdentitiesError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
ListCloudFrontOriginAccessIdentitiesError::ParseError(ref cause) => cause,
ListCloudFrontOriginAccessIdentitiesError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ListDistributionsError {
InvalidArgument(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ListDistributionsError {
pub fn from_response(res: BufferedHttpResponse) -> ListDistributionsError {
{
let reader = EventReader::new(res.body.as_slice());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"InvalidArgument" => {
return ListDistributionsError::InvalidArgument(String::from(
parsed_error.message,
));
}
_ => {}
}
}
}
ListDistributionsError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for ListDistributionsError {
fn from(err: XmlParseError) -> ListDistributionsError {
let XmlParseError(message) = err;
ListDistributionsError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for ListDistributionsError {
fn from(err: CredentialsError) -> ListDistributionsError {
ListDistributionsError::Credentials(err)
}
}
impl From<HttpDispatchError> for ListDistributionsError {
fn from(err: HttpDispatchError) -> ListDistributionsError {
ListDistributionsError::HttpDispatch(err)
}
}
impl From<io::Error> for ListDistributionsError {
fn from(err: io::Error) -> ListDistributionsError {
ListDistributionsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ListDistributionsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ListDistributionsError {
fn description(&self) -> &str {
match *self {
ListDistributionsError::InvalidArgument(ref cause) => cause,
ListDistributionsError::Validation(ref cause) => cause,
ListDistributionsError::Credentials(ref err) => err.description(),
ListDistributionsError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
ListDistributionsError::ParseError(ref cause) => cause,
ListDistributionsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ListDistributionsByWebACLIdError {
InvalidArgument(String),
InvalidWebACLId(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ListDistributionsByWebACLIdError {
pub fn from_response(res: BufferedHttpResponse) -> ListDistributionsByWebACLIdError {
{
let reader = EventReader::new(res.body.as_slice());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"InvalidArgument" => {
return ListDistributionsByWebACLIdError::InvalidArgument(String::from(
parsed_error.message,
));
}
"InvalidWebACLId" => {
return ListDistributionsByWebACLIdError::InvalidWebACLId(String::from(
parsed_error.message,
));
}
_ => {}
}
}
}
ListDistributionsByWebACLIdError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for ListDistributionsByWebACLIdError {
fn from(err: XmlParseError) -> ListDistributionsByWebACLIdError {
let XmlParseError(message) = err;
ListDistributionsByWebACLIdError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for ListDistributionsByWebACLIdError {
fn from(err: CredentialsError) -> ListDistributionsByWebACLIdError {
ListDistributionsByWebACLIdError::Credentials(err)
}
}
impl From<HttpDispatchError> for ListDistributionsByWebACLIdError {
fn from(err: HttpDispatchError) -> ListDistributionsByWebACLIdError {
ListDistributionsByWebACLIdError::HttpDispatch(err)
}
}
impl From<io::Error> for ListDistributionsByWebACLIdError {
fn from(err: io::Error) -> ListDistributionsByWebACLIdError {
ListDistributionsByWebACLIdError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ListDistributionsByWebACLIdError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ListDistributionsByWebACLIdError {
fn description(&self) -> &str {
match *self {
ListDistributionsByWebACLIdError::InvalidArgument(ref cause) => cause,
ListDistributionsByWebACLIdError::InvalidWebACLId(ref cause) => cause,
ListDistributionsByWebACLIdError::Validation(ref cause) => cause,
ListDistributionsByWebACLIdError::Credentials(ref err) => err.description(),
ListDistributionsByWebACLIdError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
ListDistributionsByWebACLIdError::ParseError(ref cause) => cause,
ListDistributionsByWebACLIdError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ListInvalidationsError {
AccessDenied(String),
InvalidArgument(String),
NoSuchDistribution(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ListInvalidationsError {
pub fn from_response(res: BufferedHttpResponse) -> ListInvalidationsError {
{
let reader = EventReader::new(res.body.as_slice());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"AccessDenied" => {
return ListInvalidationsError::AccessDenied(String::from(
parsed_error.message,
));
}
"InvalidArgument" => {
return ListInvalidationsError::InvalidArgument(String::from(
parsed_error.message,
));
}
"NoSuchDistribution" => {
return ListInvalidationsError::NoSuchDistribution(String::from(
parsed_error.message,
));
}
_ => {}
}
}
}
ListInvalidationsError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for ListInvalidationsError {
fn from(err: XmlParseError) -> ListInvalidationsError {
let XmlParseError(message) = err;
ListInvalidationsError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for ListInvalidationsError {
fn from(err: CredentialsError) -> ListInvalidationsError {
ListInvalidationsError::Credentials(err)
}
}
impl From<HttpDispatchError> for ListInvalidationsError {
fn from(err: HttpDispatchError) -> ListInvalidationsError {
ListInvalidationsError::HttpDispatch(err)
}
}
impl From<io::Error> for ListInvalidationsError {
fn from(err: io::Error) -> ListInvalidationsError {
ListInvalidationsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ListInvalidationsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ListInvalidationsError {
fn description(&self) -> &str {
match *self {
ListInvalidationsError::AccessDenied(ref cause) => cause,
ListInvalidationsError::InvalidArgument(ref cause) => cause,
ListInvalidationsError::NoSuchDistribution(ref cause) => cause,
ListInvalidationsError::Validation(ref cause) => cause,
ListInvalidationsError::Credentials(ref err) => err.description(),
ListInvalidationsError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
ListInvalidationsError::ParseError(ref cause) => cause,
ListInvalidationsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ListStreamingDistributionsError {
InvalidArgument(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ListStreamingDistributionsError {
pub fn from_response(res: BufferedHttpResponse) -> ListStreamingDistributionsError {
{
let reader = EventReader::new(res.body.as_slice());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"InvalidArgument" => {
return ListStreamingDistributionsError::InvalidArgument(String::from(
parsed_error.message,
));
}
_ => {}
}
}
}
ListStreamingDistributionsError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for ListStreamingDistributionsError {
fn from(err: XmlParseError) -> ListStreamingDistributionsError {
let XmlParseError(message) = err;
ListStreamingDistributionsError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for ListStreamingDistributionsError {
fn from(err: CredentialsError) -> ListStreamingDistributionsError {
ListStreamingDistributionsError::Credentials(err)
}
}
impl From<HttpDispatchError> for ListStreamingDistributionsError {
fn from(err: HttpDispatchError) -> ListStreamingDistributionsError {
ListStreamingDistributionsError::HttpDispatch(err)
}
}
impl From<io::Error> for ListStreamingDistributionsError {
fn from(err: io::Error) -> ListStreamingDistributionsError {
ListStreamingDistributionsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ListStreamingDistributionsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ListStreamingDistributionsError {
fn description(&self) -> &str {
match *self {
ListStreamingDistributionsError::InvalidArgument(ref cause) => cause,
ListStreamingDistributionsError::Validation(ref cause) => cause,
ListStreamingDistributionsError::Credentials(ref err) => err.description(),
ListStreamingDistributionsError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
ListStreamingDistributionsError::ParseError(ref cause) => cause,
ListStreamingDistributionsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ListTagsForResourceError {
AccessDenied(String),
InvalidArgument(String),
InvalidTagging(String),
NoSuchResource(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ListTagsForResourceError {
pub fn from_response(res: BufferedHttpResponse) -> ListTagsForResourceError {
{
let reader = EventReader::new(res.body.as_slice());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"AccessDenied" => {
return ListTagsForResourceError::AccessDenied(String::from(
parsed_error.message,
));
}
"InvalidArgument" => {
return ListTagsForResourceError::InvalidArgument(String::from(
parsed_error.message,
));
}
"InvalidTagging" => {
return ListTagsForResourceError::InvalidTagging(String::from(
parsed_error.message,
));
}
"NoSuchResource" => {
return ListTagsForResourceError::NoSuchResource(String::from(
parsed_error.message,
));
}
_ => {}
}
}
}
ListTagsForResourceError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for ListTagsForResourceError {
fn from(err: XmlParseError) -> ListTagsForResourceError {
let XmlParseError(message) = err;
ListTagsForResourceError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for ListTagsForResourceError {
fn from(err: CredentialsError) -> ListTagsForResourceError {
ListTagsForResourceError::Credentials(err)
}
}
impl From<HttpDispatchError> for ListTagsForResourceError {
fn from(err: HttpDispatchError) -> ListTagsForResourceError {
ListTagsForResourceError::HttpDispatch(err)
}
}
impl From<io::Error> for ListTagsForResourceError {
fn from(err: io::Error) -> ListTagsForResourceError {
ListTagsForResourceError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ListTagsForResourceError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ListTagsForResourceError {
fn description(&self) -> &str {
match *self {
ListTagsForResourceError::AccessDenied(ref cause) => cause,
ListTagsForResourceError::InvalidArgument(ref cause) => cause,
ListTagsForResourceError::InvalidTagging(ref cause) => cause,
ListTagsForResourceError::NoSuchResource(ref cause) => cause,
ListTagsForResourceError::Validation(ref cause) => cause,
ListTagsForResourceError::Credentials(ref err) => err.description(),
ListTagsForResourceError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
ListTagsForResourceError::ParseError(ref cause) => cause,
ListTagsForResourceError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum TagResourceError {
AccessDenied(String),
InvalidArgument(String),
InvalidTagging(String),
NoSuchResource(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl TagResourceError {
pub fn from_response(res: BufferedHttpResponse) -> TagResourceError {
{
let reader = EventReader::new(res.body.as_slice());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"AccessDenied" => {
return TagResourceError::AccessDenied(String::from(parsed_error.message));
}
"InvalidArgument" => {
return TagResourceError::InvalidArgument(String::from(parsed_error.message));
}
"InvalidTagging" => {
return TagResourceError::InvalidTagging(String::from(parsed_error.message));
}
"NoSuchResource" => {
return TagResourceError::NoSuchResource(String::from(parsed_error.message));
}
_ => {}
}
}
}
TagResourceError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for TagResourceError {
fn from(err: XmlParseError) -> TagResourceError {
let XmlParseError(message) = err;
TagResourceError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for TagResourceError {
fn from(err: CredentialsError) -> TagResourceError {
TagResourceError::Credentials(err)
}
}
impl From<HttpDispatchError> for TagResourceError {
fn from(err: HttpDispatchError) -> TagResourceError {
TagResourceError::HttpDispatch(err)
}
}
impl From<io::Error> for TagResourceError {
fn from(err: io::Error) -> TagResourceError {
TagResourceError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for TagResourceError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for TagResourceError {
fn description(&self) -> &str {
match *self {
TagResourceError::AccessDenied(ref cause) => cause,
TagResourceError::InvalidArgument(ref cause) => cause,
TagResourceError::InvalidTagging(ref cause) => cause,
TagResourceError::NoSuchResource(ref cause) => cause,
TagResourceError::Validation(ref cause) => cause,
TagResourceError::Credentials(ref err) => err.description(),
TagResourceError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
TagResourceError::ParseError(ref cause) => cause,
TagResourceError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum UntagResourceError {
AccessDenied(String),
InvalidArgument(String),
InvalidTagging(String),
NoSuchResource(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl UntagResourceError {
pub fn from_response(res: BufferedHttpResponse) -> UntagResourceError {
{
let reader = EventReader::new(res.body.as_slice());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"AccessDenied" => {
return UntagResourceError::AccessDenied(String::from(parsed_error.message));
}
"InvalidArgument" => {
return UntagResourceError::InvalidArgument(String::from(
parsed_error.message,
));
}
"InvalidTagging" => {
return UntagResourceError::InvalidTagging(String::from(
parsed_error.message,
));
}
"NoSuchResource" => {
return UntagResourceError::NoSuchResource(String::from(
parsed_error.message,
));
}
_ => {}
}
}
}
UntagResourceError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for UntagResourceError {
fn from(err: XmlParseError) -> UntagResourceError {
let XmlParseError(message) = err;
UntagResourceError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for UntagResourceError {
fn from(err: CredentialsError) -> UntagResourceError {
UntagResourceError::Credentials(err)
}
}
impl From<HttpDispatchError> for UntagResourceError {
fn from(err: HttpDispatchError) -> UntagResourceError {
UntagResourceError::HttpDispatch(err)
}
}
impl From<io::Error> for UntagResourceError {
fn from(err: io::Error) -> UntagResourceError {
UntagResourceError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for UntagResourceError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for UntagResourceError {
fn description(&self) -> &str {
match *self {
UntagResourceError::AccessDenied(ref cause) => cause,
UntagResourceError::InvalidArgument(ref cause) => cause,
UntagResourceError::InvalidTagging(ref cause) => cause,
UntagResourceError::NoSuchResource(ref cause) => cause,
UntagResourceError::Validation(ref cause) => cause,
UntagResourceError::Credentials(ref err) => err.description(),
UntagResourceError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
UntagResourceError::ParseError(ref cause) => cause,
UntagResourceError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum UpdateCloudFrontOriginAccessIdentityError {
AccessDenied(String),
IllegalUpdate(String),
InconsistentQuantities(String),
InvalidArgument(String),
InvalidIfMatchVersion(String),
MissingBody(String),
NoSuchCloudFrontOriginAccessIdentity(String),
PreconditionFailed(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl UpdateCloudFrontOriginAccessIdentityError {
pub fn from_response(res: BufferedHttpResponse) -> UpdateCloudFrontOriginAccessIdentityError {
{
let reader = EventReader::new(res.body.as_slice());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"AccessDenied" => return UpdateCloudFrontOriginAccessIdentityError::AccessDenied(String::from(parsed_error.message)),"IllegalUpdate" => return UpdateCloudFrontOriginAccessIdentityError::IllegalUpdate(String::from(parsed_error.message)),"InconsistentQuantities" => return UpdateCloudFrontOriginAccessIdentityError::InconsistentQuantities(String::from(parsed_error.message)),"InvalidArgument" => return UpdateCloudFrontOriginAccessIdentityError::InvalidArgument(String::from(parsed_error.message)),"InvalidIfMatchVersion" => return UpdateCloudFrontOriginAccessIdentityError::InvalidIfMatchVersion(String::from(parsed_error.message)),"MissingBody" => return UpdateCloudFrontOriginAccessIdentityError::MissingBody(String::from(parsed_error.message)),"NoSuchCloudFrontOriginAccessIdentity" => return UpdateCloudFrontOriginAccessIdentityError::NoSuchCloudFrontOriginAccessIdentity(String::from(parsed_error.message)),"PreconditionFailed" => return UpdateCloudFrontOriginAccessIdentityError::PreconditionFailed(String::from(parsed_error.message)),_ => {}
}
}
}
UpdateCloudFrontOriginAccessIdentityError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for UpdateCloudFrontOriginAccessIdentityError {
fn from(err: XmlParseError) -> UpdateCloudFrontOriginAccessIdentityError {
let XmlParseError(message) = err;
UpdateCloudFrontOriginAccessIdentityError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for UpdateCloudFrontOriginAccessIdentityError {
fn from(err: CredentialsError) -> UpdateCloudFrontOriginAccessIdentityError {
UpdateCloudFrontOriginAccessIdentityError::Credentials(err)
}
}
impl From<HttpDispatchError> for UpdateCloudFrontOriginAccessIdentityError {
fn from(err: HttpDispatchError) -> UpdateCloudFrontOriginAccessIdentityError {
UpdateCloudFrontOriginAccessIdentityError::HttpDispatch(err)
}
}
impl From<io::Error> for UpdateCloudFrontOriginAccessIdentityError {
fn from(err: io::Error) -> UpdateCloudFrontOriginAccessIdentityError {
UpdateCloudFrontOriginAccessIdentityError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for UpdateCloudFrontOriginAccessIdentityError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for UpdateCloudFrontOriginAccessIdentityError {
fn description(&self) -> &str {
match *self {
UpdateCloudFrontOriginAccessIdentityError::AccessDenied(ref cause) => cause,
UpdateCloudFrontOriginAccessIdentityError::IllegalUpdate(ref cause) => cause,
UpdateCloudFrontOriginAccessIdentityError::InconsistentQuantities(ref cause) => cause,
UpdateCloudFrontOriginAccessIdentityError::InvalidArgument(ref cause) => cause,
UpdateCloudFrontOriginAccessIdentityError::InvalidIfMatchVersion(ref cause) => cause,
UpdateCloudFrontOriginAccessIdentityError::MissingBody(ref cause) => cause,
UpdateCloudFrontOriginAccessIdentityError::NoSuchCloudFrontOriginAccessIdentity(
ref cause,
) => cause,
UpdateCloudFrontOriginAccessIdentityError::PreconditionFailed(ref cause) => cause,
UpdateCloudFrontOriginAccessIdentityError::Validation(ref cause) => cause,
UpdateCloudFrontOriginAccessIdentityError::Credentials(ref err) => err.description(),
UpdateCloudFrontOriginAccessIdentityError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
UpdateCloudFrontOriginAccessIdentityError::ParseError(ref cause) => cause,
UpdateCloudFrontOriginAccessIdentityError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum UpdateDistributionError {
AccessDenied(String),
CNAMEAlreadyExists(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),
NoSuchOrigin(String),
PreconditionFailed(String),
TooManyCacheBehaviors(String),
TooManyCertificates(String),
TooManyCookieNamesInWhiteList(String),
TooManyDistributionCNAMEs(String),
TooManyDistributionsWithLambdaAssociations(String),
TooManyHeadersInForwardedValues(String),
TooManyLambdaFunctionAssociations(String),
TooManyOriginCustomHeaders(String),
TooManyOrigins(String),
TooManyQueryStringParameters(String),
TooManyTrustedSigners(String),
TrustedSignerDoesNotExist(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl UpdateDistributionError {
pub fn from_response(res: BufferedHttpResponse) -> UpdateDistributionError {
{
let reader = EventReader::new(res.body.as_slice());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"AccessDenied" => {
return UpdateDistributionError::AccessDenied(String::from(
parsed_error.message,
));
}
"CNAMEAlreadyExists" => {
return UpdateDistributionError::CNAMEAlreadyExists(String::from(
parsed_error.message,
));
}
"IllegalUpdate" => {
return UpdateDistributionError::IllegalUpdate(String::from(
parsed_error.message,
));
}
"InconsistentQuantities" => {
return UpdateDistributionError::InconsistentQuantities(String::from(
parsed_error.message,
));
}
"InvalidArgument" => {
return UpdateDistributionError::InvalidArgument(String::from(
parsed_error.message,
));
}
"InvalidDefaultRootObject" => {
return UpdateDistributionError::InvalidDefaultRootObject(String::from(
parsed_error.message,
));
}
"InvalidErrorCode" => {
return UpdateDistributionError::InvalidErrorCode(String::from(
parsed_error.message,
));
}
"InvalidForwardCookies" => {
return UpdateDistributionError::InvalidForwardCookies(String::from(
parsed_error.message,
));
}
"InvalidGeoRestrictionParameter" => {
return UpdateDistributionError::InvalidGeoRestrictionParameter(
String::from(parsed_error.message),
);
}
"InvalidHeadersForS3Origin" => {
return UpdateDistributionError::InvalidHeadersForS3Origin(String::from(
parsed_error.message,
));
}
"InvalidIfMatchVersion" => {
return UpdateDistributionError::InvalidIfMatchVersion(String::from(
parsed_error.message,
));
}
"InvalidLambdaFunctionAssociation" => {
return UpdateDistributionError::InvalidLambdaFunctionAssociation(
String::from(parsed_error.message),
);
}
"InvalidLocationCode" => {
return UpdateDistributionError::InvalidLocationCode(String::from(
parsed_error.message,
));
}
"InvalidMinimumProtocolVersion" => {
return UpdateDistributionError::InvalidMinimumProtocolVersion(String::from(
parsed_error.message,
));
}
"InvalidOriginAccessIdentity" => {
return UpdateDistributionError::InvalidOriginAccessIdentity(String::from(
parsed_error.message,
));
}
"InvalidOriginKeepaliveTimeout" => {
return UpdateDistributionError::InvalidOriginKeepaliveTimeout(String::from(
parsed_error.message,
));
}
"InvalidOriginReadTimeout" => {
return UpdateDistributionError::InvalidOriginReadTimeout(String::from(
parsed_error.message,
));
}
"InvalidQueryStringParameters" => {
return UpdateDistributionError::InvalidQueryStringParameters(String::from(
parsed_error.message,
));
}
"InvalidRelativePath" => {
return UpdateDistributionError::InvalidRelativePath(String::from(
parsed_error.message,
));
}
"InvalidRequiredProtocol" => {
return UpdateDistributionError::InvalidRequiredProtocol(String::from(
parsed_error.message,
));
}
"InvalidResponseCode" => {
return UpdateDistributionError::InvalidResponseCode(String::from(
parsed_error.message,
));
}
"InvalidTTLOrder" => {
return UpdateDistributionError::InvalidTTLOrder(String::from(
parsed_error.message,
));
}
"InvalidViewerCertificate" => {
return UpdateDistributionError::InvalidViewerCertificate(String::from(
parsed_error.message,
));
}
"InvalidWebACLId" => {
return UpdateDistributionError::InvalidWebACLId(String::from(
parsed_error.message,
));
}
"MissingBody" => {
return UpdateDistributionError::MissingBody(String::from(
parsed_error.message,
));
}
"NoSuchDistribution" => {
return UpdateDistributionError::NoSuchDistribution(String::from(
parsed_error.message,
));
}
"NoSuchOrigin" => {
return UpdateDistributionError::NoSuchOrigin(String::from(
parsed_error.message,
));
}
"PreconditionFailed" => {
return UpdateDistributionError::PreconditionFailed(String::from(
parsed_error.message,
));
}
"TooManyCacheBehaviors" => {
return UpdateDistributionError::TooManyCacheBehaviors(String::from(
parsed_error.message,
));
}
"TooManyCertificates" => {
return UpdateDistributionError::TooManyCertificates(String::from(
parsed_error.message,
));
}
"TooManyCookieNamesInWhiteList" => {
return UpdateDistributionError::TooManyCookieNamesInWhiteList(String::from(
parsed_error.message,
));
}
"TooManyDistributionCNAMEs" => {
return UpdateDistributionError::TooManyDistributionCNAMEs(String::from(
parsed_error.message,
));
}
"TooManyDistributionsWithLambdaAssociations" => {
return UpdateDistributionError::TooManyDistributionsWithLambdaAssociations(
String::from(parsed_error.message),
);
}
"TooManyHeadersInForwardedValues" => {
return UpdateDistributionError::TooManyHeadersInForwardedValues(
String::from(parsed_error.message),
);
}
"TooManyLambdaFunctionAssociations" => {
return UpdateDistributionError::TooManyLambdaFunctionAssociations(
String::from(parsed_error.message),
);
}
"TooManyOriginCustomHeaders" => {
return UpdateDistributionError::TooManyOriginCustomHeaders(String::from(
parsed_error.message,
));
}
"TooManyOrigins" => {
return UpdateDistributionError::TooManyOrigins(String::from(
parsed_error.message,
));
}
"TooManyQueryStringParameters" => {
return UpdateDistributionError::TooManyQueryStringParameters(String::from(
parsed_error.message,
));
}
"TooManyTrustedSigners" => {
return UpdateDistributionError::TooManyTrustedSigners(String::from(
parsed_error.message,
));
}
"TrustedSignerDoesNotExist" => {
return UpdateDistributionError::TrustedSignerDoesNotExist(String::from(
parsed_error.message,
));
}
_ => {}
}
}
}
UpdateDistributionError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for UpdateDistributionError {
fn from(err: XmlParseError) -> UpdateDistributionError {
let XmlParseError(message) = err;
UpdateDistributionError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for UpdateDistributionError {
fn from(err: CredentialsError) -> UpdateDistributionError {
UpdateDistributionError::Credentials(err)
}
}
impl From<HttpDispatchError> for UpdateDistributionError {
fn from(err: HttpDispatchError) -> UpdateDistributionError {
UpdateDistributionError::HttpDispatch(err)
}
}
impl From<io::Error> for UpdateDistributionError {
fn from(err: io::Error) -> UpdateDistributionError {
UpdateDistributionError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for UpdateDistributionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for UpdateDistributionError {
fn description(&self) -> &str {
match *self {
UpdateDistributionError::AccessDenied(ref cause) => cause,
UpdateDistributionError::CNAMEAlreadyExists(ref cause) => cause,
UpdateDistributionError::IllegalUpdate(ref cause) => cause,
UpdateDistributionError::InconsistentQuantities(ref cause) => cause,
UpdateDistributionError::InvalidArgument(ref cause) => cause,
UpdateDistributionError::InvalidDefaultRootObject(ref cause) => cause,
UpdateDistributionError::InvalidErrorCode(ref cause) => cause,
UpdateDistributionError::InvalidForwardCookies(ref cause) => cause,
UpdateDistributionError::InvalidGeoRestrictionParameter(ref cause) => cause,
UpdateDistributionError::InvalidHeadersForS3Origin(ref cause) => cause,
UpdateDistributionError::InvalidIfMatchVersion(ref cause) => cause,
UpdateDistributionError::InvalidLambdaFunctionAssociation(ref cause) => cause,
UpdateDistributionError::InvalidLocationCode(ref cause) => cause,
UpdateDistributionError::InvalidMinimumProtocolVersion(ref cause) => cause,
UpdateDistributionError::InvalidOriginAccessIdentity(ref cause) => cause,
UpdateDistributionError::InvalidOriginKeepaliveTimeout(ref cause) => cause,
UpdateDistributionError::InvalidOriginReadTimeout(ref cause) => cause,
UpdateDistributionError::InvalidQueryStringParameters(ref cause) => cause,
UpdateDistributionError::InvalidRelativePath(ref cause) => cause,
UpdateDistributionError::InvalidRequiredProtocol(ref cause) => cause,
UpdateDistributionError::InvalidResponseCode(ref cause) => cause,
UpdateDistributionError::InvalidTTLOrder(ref cause) => cause,
UpdateDistributionError::InvalidViewerCertificate(ref cause) => cause,
UpdateDistributionError::InvalidWebACLId(ref cause) => cause,
UpdateDistributionError::MissingBody(ref cause) => cause,
UpdateDistributionError::NoSuchDistribution(ref cause) => cause,
UpdateDistributionError::NoSuchOrigin(ref cause) => cause,
UpdateDistributionError::PreconditionFailed(ref cause) => cause,
UpdateDistributionError::TooManyCacheBehaviors(ref cause) => cause,
UpdateDistributionError::TooManyCertificates(ref cause) => cause,
UpdateDistributionError::TooManyCookieNamesInWhiteList(ref cause) => cause,
UpdateDistributionError::TooManyDistributionCNAMEs(ref cause) => cause,
UpdateDistributionError::TooManyDistributionsWithLambdaAssociations(ref cause) => cause,
UpdateDistributionError::TooManyHeadersInForwardedValues(ref cause) => cause,
UpdateDistributionError::TooManyLambdaFunctionAssociations(ref cause) => cause,
UpdateDistributionError::TooManyOriginCustomHeaders(ref cause) => cause,
UpdateDistributionError::TooManyOrigins(ref cause) => cause,
UpdateDistributionError::TooManyQueryStringParameters(ref cause) => cause,
UpdateDistributionError::TooManyTrustedSigners(ref cause) => cause,
UpdateDistributionError::TrustedSignerDoesNotExist(ref cause) => cause,
UpdateDistributionError::Validation(ref cause) => cause,
UpdateDistributionError::Credentials(ref err) => err.description(),
UpdateDistributionError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
UpdateDistributionError::ParseError(ref cause) => cause,
UpdateDistributionError::Unknown(_) => "unknown error",
}
}
}
#[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),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl UpdateStreamingDistributionError {
pub fn from_response(res: BufferedHttpResponse) -> UpdateStreamingDistributionError {
{
let reader = EventReader::new(res.body.as_slice());
let mut stack = XmlResponse::new(reader.into_iter().peekable());
find_start_element(&mut stack);
if let Ok(parsed_error) = Self::deserialize(&mut stack) {
match &parsed_error.code[..] {
"AccessDenied" => {
return UpdateStreamingDistributionError::AccessDenied(String::from(
parsed_error.message,
));
}
"CNAMEAlreadyExists" => {
return UpdateStreamingDistributionError::CNAMEAlreadyExists(String::from(
parsed_error.message,
));
}
"IllegalUpdate" => {
return UpdateStreamingDistributionError::IllegalUpdate(String::from(
parsed_error.message,
));
}
"InconsistentQuantities" => {
return UpdateStreamingDistributionError::InconsistentQuantities(
String::from(parsed_error.message),
);
}
"InvalidArgument" => {
return UpdateStreamingDistributionError::InvalidArgument(String::from(
parsed_error.message,
));
}
"InvalidIfMatchVersion" => {
return UpdateStreamingDistributionError::InvalidIfMatchVersion(
String::from(parsed_error.message),
);
}
"InvalidOriginAccessIdentity" => {
return UpdateStreamingDistributionError::InvalidOriginAccessIdentity(
String::from(parsed_error.message),
);
}
"MissingBody" => {
return UpdateStreamingDistributionError::MissingBody(String::from(
parsed_error.message,
));
}
"NoSuchStreamingDistribution" => {
return UpdateStreamingDistributionError::NoSuchStreamingDistribution(
String::from(parsed_error.message),
);
}
"PreconditionFailed" => {
return UpdateStreamingDistributionError::PreconditionFailed(String::from(
parsed_error.message,
));
}
"TooManyStreamingDistributionCNAMEs" => {
return UpdateStreamingDistributionError::TooManyStreamingDistributionCNAMEs(
String::from(parsed_error.message),
);
}
"TooManyTrustedSigners" => {
return UpdateStreamingDistributionError::TooManyTrustedSigners(
String::from(parsed_error.message),
);
}
"TrustedSignerDoesNotExist" => {
return UpdateStreamingDistributionError::TrustedSignerDoesNotExist(
String::from(parsed_error.message),
);
}
_ => {}
}
}
}
UpdateStreamingDistributionError::Unknown(res)
}
fn deserialize<T>(stack: &mut T) -> Result<XmlError, XmlParseError>
where
T: Peek + Next,
{
start_element("ErrorResponse", stack)?;
XmlErrorDeserializer::deserialize("Error", stack)
}
}
impl From<XmlParseError> for UpdateStreamingDistributionError {
fn from(err: XmlParseError) -> UpdateStreamingDistributionError {
let XmlParseError(message) = err;
UpdateStreamingDistributionError::ParseError(message.to_string())
}
}
impl From<CredentialsError> for UpdateStreamingDistributionError {
fn from(err: CredentialsError) -> UpdateStreamingDistributionError {
UpdateStreamingDistributionError::Credentials(err)
}
}
impl From<HttpDispatchError> for UpdateStreamingDistributionError {
fn from(err: HttpDispatchError) -> UpdateStreamingDistributionError {
UpdateStreamingDistributionError::HttpDispatch(err)
}
}
impl From<io::Error> for UpdateStreamingDistributionError {
fn from(err: io::Error) -> UpdateStreamingDistributionError {
UpdateStreamingDistributionError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for UpdateStreamingDistributionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for UpdateStreamingDistributionError {
fn description(&self) -> &str {
match *self {
UpdateStreamingDistributionError::AccessDenied(ref cause) => cause,
UpdateStreamingDistributionError::CNAMEAlreadyExists(ref cause) => cause,
UpdateStreamingDistributionError::IllegalUpdate(ref cause) => cause,
UpdateStreamingDistributionError::InconsistentQuantities(ref cause) => cause,
UpdateStreamingDistributionError::InvalidArgument(ref cause) => cause,
UpdateStreamingDistributionError::InvalidIfMatchVersion(ref cause) => cause,
UpdateStreamingDistributionError::InvalidOriginAccessIdentity(ref cause) => cause,
UpdateStreamingDistributionError::MissingBody(ref cause) => cause,
UpdateStreamingDistributionError::NoSuchStreamingDistribution(ref cause) => cause,
UpdateStreamingDistributionError::PreconditionFailed(ref cause) => cause,
UpdateStreamingDistributionError::TooManyStreamingDistributionCNAMEs(ref cause) => {
cause
}
UpdateStreamingDistributionError::TooManyTrustedSigners(ref cause) => cause,
UpdateStreamingDistributionError::TrustedSignerDoesNotExist(ref cause) => cause,
UpdateStreamingDistributionError::Validation(ref cause) => cause,
UpdateStreamingDistributionError::Credentials(ref err) => err.description(),
UpdateStreamingDistributionError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
UpdateStreamingDistributionError::ParseError(ref cause) => cause,
UpdateStreamingDistributionError::Unknown(_) => "unknown error",
}
}
}
pub trait CloudFront {
fn create_cloud_front_origin_access_identity(
&self,
input: CreateCloudFrontOriginAccessIdentityRequest,
) -> RusotoFuture<
CreateCloudFrontOriginAccessIdentityResult,
CreateCloudFrontOriginAccessIdentityError,
>;
fn create_distribution(
&self,
input: CreateDistributionRequest,
) -> RusotoFuture<CreateDistributionResult, CreateDistributionError>;
fn create_distribution_with_tags(
&self,
input: CreateDistributionWithTagsRequest,
) -> RusotoFuture<CreateDistributionWithTagsResult, CreateDistributionWithTagsError>;
fn create_invalidation(
&self,
input: CreateInvalidationRequest,
) -> RusotoFuture<CreateInvalidationResult, CreateInvalidationError>;
fn create_streaming_distribution(
&self,
input: CreateStreamingDistributionRequest,
) -> RusotoFuture<CreateStreamingDistributionResult, CreateStreamingDistributionError>;
fn create_streaming_distribution_with_tags(
&self,
input: CreateStreamingDistributionWithTagsRequest,
) -> RusotoFuture<
CreateStreamingDistributionWithTagsResult,
CreateStreamingDistributionWithTagsError,
>;
fn delete_cloud_front_origin_access_identity(
&self,
input: DeleteCloudFrontOriginAccessIdentityRequest,
) -> RusotoFuture<(), DeleteCloudFrontOriginAccessIdentityError>;
fn delete_distribution(
&self,
input: DeleteDistributionRequest,
) -> RusotoFuture<(), DeleteDistributionError>;
fn delete_service_linked_role(
&self,
input: DeleteServiceLinkedRoleRequest,
) -> RusotoFuture<(), DeleteServiceLinkedRoleError>;
fn delete_streaming_distribution(
&self,
input: DeleteStreamingDistributionRequest,
) -> RusotoFuture<(), DeleteStreamingDistributionError>;
fn get_cloud_front_origin_access_identity(
&self,
input: GetCloudFrontOriginAccessIdentityRequest,
) -> RusotoFuture<GetCloudFrontOriginAccessIdentityResult, GetCloudFrontOriginAccessIdentityError>;
fn get_cloud_front_origin_access_identity_config(
&self,
input: GetCloudFrontOriginAccessIdentityConfigRequest,
) -> RusotoFuture<
GetCloudFrontOriginAccessIdentityConfigResult,
GetCloudFrontOriginAccessIdentityConfigError,
>;
fn get_distribution(
&self,
input: GetDistributionRequest,
) -> RusotoFuture<GetDistributionResult, GetDistributionError>;
fn get_distribution_config(
&self,
input: GetDistributionConfigRequest,
) -> RusotoFuture<GetDistributionConfigResult, GetDistributionConfigError>;
fn get_invalidation(
&self,
input: GetInvalidationRequest,
) -> RusotoFuture<GetInvalidationResult, GetInvalidationError>;
fn get_streaming_distribution(
&self,
input: GetStreamingDistributionRequest,
) -> RusotoFuture<GetStreamingDistributionResult, GetStreamingDistributionError>;
fn get_streaming_distribution_config(
&self,
input: GetStreamingDistributionConfigRequest,
) -> RusotoFuture<GetStreamingDistributionConfigResult, GetStreamingDistributionConfigError>;
fn list_cloud_front_origin_access_identities(
&self,
input: ListCloudFrontOriginAccessIdentitiesRequest,
) -> RusotoFuture<
ListCloudFrontOriginAccessIdentitiesResult,
ListCloudFrontOriginAccessIdentitiesError,
>;
fn list_distributions(
&self,
input: ListDistributionsRequest,
) -> RusotoFuture<ListDistributionsResult, ListDistributionsError>;
fn list_distributions_by_web_acl_id(
&self,
input: ListDistributionsByWebACLIdRequest,
) -> RusotoFuture<ListDistributionsByWebACLIdResult, ListDistributionsByWebACLIdError>;
fn list_invalidations(
&self,
input: ListInvalidationsRequest,
) -> RusotoFuture<ListInvalidationsResult, ListInvalidationsError>;
fn list_streaming_distributions(
&self,
input: ListStreamingDistributionsRequest,
) -> RusotoFuture<ListStreamingDistributionsResult, ListStreamingDistributionsError>;
fn list_tags_for_resource(
&self,
input: ListTagsForResourceRequest,
) -> RusotoFuture<ListTagsForResourceResult, ListTagsForResourceError>;
fn tag_resource(&self, input: TagResourceRequest) -> RusotoFuture<(), TagResourceError>;
fn untag_resource(&self, input: UntagResourceRequest) -> RusotoFuture<(), UntagResourceError>;
fn update_cloud_front_origin_access_identity(
&self,
input: UpdateCloudFrontOriginAccessIdentityRequest,
) -> RusotoFuture<
UpdateCloudFrontOriginAccessIdentityResult,
UpdateCloudFrontOriginAccessIdentityError,
>;
fn update_distribution(
&self,
input: UpdateDistributionRequest,
) -> RusotoFuture<UpdateDistributionResult, UpdateDistributionError>;
fn update_streaming_distribution(
&self,
input: UpdateStreamingDistributionRequest,
) -> RusotoFuture<UpdateStreamingDistributionResult, 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: region,
}
}
pub fn new_with<P, D>(
request_dispatcher: D,
credentials_provider: P,
region: region::Region,
) -> CloudFrontClient
where
P: ProvideAwsCredentials + Send + Sync + 'static,
P::Future: Send,
D: DispatchSignedRequest + Send + Sync + 'static,
D::Future: Send,
{
CloudFrontClient {
client: Client::new_with(credentials_provider, request_dispatcher),
region: region,
}
}
}
impl CloudFront for CloudFrontClient {
#[allow(unused_variables, warnings)]
fn create_cloud_front_origin_access_identity(
&self,
input: CreateCloudFrontOriginAccessIdentityRequest,
) -> RusotoFuture<
CreateCloudFrontOriginAccessIdentityResult,
CreateCloudFrontOriginAccessIdentityError,
> {
let request_uri = "/2017-03-25/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()));
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(CreateCloudFrontOriginAccessIdentityError::from_response(
response,
))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let mut result;
if response.body.is_empty() {
result = CreateCloudFrontOriginAccessIdentityResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = CreateCloudFrontOriginAccessIdentityResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
if let Some(e_tag) = response.headers.get("ETag") {
let value = e_tag.to_owned();
result.e_tag = Some(value)
};
if let Some(location) = response.headers.get("Location") {
let value = location.to_owned();
result.location = Some(value)
};
Ok(result)
}))
})
}
#[allow(unused_variables, warnings)]
fn create_distribution(
&self,
input: CreateDistributionRequest,
) -> RusotoFuture<CreateDistributionResult, CreateDistributionError> {
let request_uri = "/2017-03-25/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()));
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(CreateDistributionError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let mut result;
if response.body.is_empty() {
result = CreateDistributionResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = CreateDistributionResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
if let Some(e_tag) = response.headers.get("ETag") {
let value = e_tag.to_owned();
result.e_tag = Some(value)
};
if let Some(location) = response.headers.get("Location") {
let value = location.to_owned();
result.location = Some(value)
};
Ok(result)
}))
})
}
#[allow(unused_variables, warnings)]
fn create_distribution_with_tags(
&self,
input: CreateDistributionWithTagsRequest,
) -> RusotoFuture<CreateDistributionWithTagsResult, CreateDistributionWithTagsError> {
let request_uri = "/2017-03-25/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()));
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(CreateDistributionWithTagsError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let mut result;
if response.body.is_empty() {
result = CreateDistributionWithTagsResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = CreateDistributionWithTagsResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
if let Some(e_tag) = response.headers.get("ETag") {
let value = e_tag.to_owned();
result.e_tag = Some(value)
};
if let Some(location) = response.headers.get("Location") {
let value = location.to_owned();
result.location = Some(value)
};
Ok(result)
}))
})
}
#[allow(unused_variables, warnings)]
fn create_invalidation(
&self,
input: CreateInvalidationRequest,
) -> RusotoFuture<CreateInvalidationResult, CreateInvalidationError> {
let request_uri = format!(
"/2017-03-25/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()));
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(CreateInvalidationError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let mut result;
if response.body.is_empty() {
result = CreateInvalidationResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = CreateInvalidationResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
if let Some(location) = response.headers.get("Location") {
let value = location.to_owned();
result.location = Some(value)
};
Ok(result)
}))
})
}
#[allow(unused_variables, warnings)]
fn create_streaming_distribution(
&self,
input: CreateStreamingDistributionRequest,
) -> RusotoFuture<CreateStreamingDistributionResult, CreateStreamingDistributionError> {
let request_uri = "/2017-03-25/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()));
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(CreateStreamingDistributionError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let mut result;
if response.body.is_empty() {
result = CreateStreamingDistributionResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = CreateStreamingDistributionResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
if let Some(e_tag) = response.headers.get("ETag") {
let value = e_tag.to_owned();
result.e_tag = Some(value)
};
if let Some(location) = response.headers.get("Location") {
let value = location.to_owned();
result.location = Some(value)
};
Ok(result)
}))
})
}
#[allow(unused_variables, warnings)]
fn create_streaming_distribution_with_tags(
&self,
input: CreateStreamingDistributionWithTagsRequest,
) -> RusotoFuture<
CreateStreamingDistributionWithTagsResult,
CreateStreamingDistributionWithTagsError,
> {
let request_uri = "/2017-03-25/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()));
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(CreateStreamingDistributionWithTagsError::from_response(
response,
))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let mut result;
if response.body.is_empty() {
result = CreateStreamingDistributionWithTagsResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = CreateStreamingDistributionWithTagsResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
if let Some(e_tag) = response.headers.get("ETag") {
let value = e_tag.to_owned();
result.e_tag = Some(value)
};
if let Some(location) = response.headers.get("Location") {
let value = location.to_owned();
result.location = Some(value)
};
Ok(result)
}))
})
}
#[allow(unused_variables, warnings)]
fn delete_cloud_front_origin_access_identity(
&self,
input: DeleteCloudFrontOriginAccessIdentityRequest,
) -> RusotoFuture<(), DeleteCloudFrontOriginAccessIdentityError> {
let request_uri = format!(
"/2017-03-25/origin-access-identity/cloudfront/{id}",
id = input.id
);
let mut request = SignedRequest::new("DELETE", "cloudfront", &self.region, &request_uri);
if let Some(ref if_match) = input.if_match {
request.add_header("If-Match", &if_match.to_string());
}
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DeleteCloudFrontOriginAccessIdentityError::from_response(
response,
))
}));
}
Box::new(future::ok(::std::mem::drop(response)))
})
}
#[allow(unused_variables, warnings)]
fn delete_distribution(
&self,
input: DeleteDistributionRequest,
) -> RusotoFuture<(), DeleteDistributionError> {
let request_uri = format!("/2017-03-25/distribution/{id}", id = input.id);
let mut request = SignedRequest::new("DELETE", "cloudfront", &self.region, &request_uri);
if let Some(ref if_match) = input.if_match {
request.add_header("If-Match", &if_match.to_string());
}
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DeleteDistributionError::from_response(response))),
);
}
Box::new(future::ok(::std::mem::drop(response)))
})
}
#[allow(unused_variables, warnings)]
fn delete_service_linked_role(
&self,
input: DeleteServiceLinkedRoleRequest,
) -> RusotoFuture<(), DeleteServiceLinkedRoleError> {
let request_uri = format!(
"/2017-03-25/service-linked-role/{role_name}",
role_name = input.role_name
);
let mut request = SignedRequest::new("DELETE", "cloudfront", &self.region, &request_uri);
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DeleteServiceLinkedRoleError::from_response(response))
}));
}
Box::new(future::ok(::std::mem::drop(response)))
})
}
#[allow(unused_variables, warnings)]
fn delete_streaming_distribution(
&self,
input: DeleteStreamingDistributionRequest,
) -> RusotoFuture<(), DeleteStreamingDistributionError> {
let request_uri = format!("/2017-03-25/streaming-distribution/{id}", id = input.id);
let mut request = SignedRequest::new("DELETE", "cloudfront", &self.region, &request_uri);
if let Some(ref if_match) = input.if_match {
request.add_header("If-Match", &if_match.to_string());
}
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(DeleteStreamingDistributionError::from_response(response))
}));
}
Box::new(future::ok(::std::mem::drop(response)))
})
}
#[allow(unused_variables, warnings)]
fn get_cloud_front_origin_access_identity(
&self,
input: GetCloudFrontOriginAccessIdentityRequest,
) -> RusotoFuture<GetCloudFrontOriginAccessIdentityResult, GetCloudFrontOriginAccessIdentityError>
{
let request_uri = format!(
"/2017-03-25/origin-access-identity/cloudfront/{id}",
id = input.id
);
let mut request = SignedRequest::new("GET", "cloudfront", &self.region, &request_uri);
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(GetCloudFrontOriginAccessIdentityError::from_response(
response,
))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let mut result;
if response.body.is_empty() {
result = GetCloudFrontOriginAccessIdentityResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = GetCloudFrontOriginAccessIdentityResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
if let Some(e_tag) = response.headers.get("ETag") {
let value = e_tag.to_owned();
result.e_tag = Some(value)
};
Ok(result)
}))
})
}
#[allow(unused_variables, warnings)]
fn get_cloud_front_origin_access_identity_config(
&self,
input: GetCloudFrontOriginAccessIdentityConfigRequest,
) -> RusotoFuture<
GetCloudFrontOriginAccessIdentityConfigResult,
GetCloudFrontOriginAccessIdentityConfigError,
> {
let request_uri = format!(
"/2017-03-25/origin-access-identity/cloudfront/{id}/config",
id = input.id
);
let mut request = SignedRequest::new("GET", "cloudfront", &self.region, &request_uri);
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(GetCloudFrontOriginAccessIdentityConfigError::from_response(
response,
))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let mut result;
if response.body.is_empty() {
result = GetCloudFrontOriginAccessIdentityConfigResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result =
GetCloudFrontOriginAccessIdentityConfigResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
if let Some(e_tag) = response.headers.get("ETag") {
let value = e_tag.to_owned();
result.e_tag = Some(value)
};
Ok(result)
}))
})
}
#[allow(unused_variables, warnings)]
fn get_distribution(
&self,
input: GetDistributionRequest,
) -> RusotoFuture<GetDistributionResult, GetDistributionError> {
let request_uri = format!("/2017-03-25/distribution/{id}", id = input.id);
let mut request = SignedRequest::new("GET", "cloudfront", &self.region, &request_uri);
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(GetDistributionError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let mut result;
if response.body.is_empty() {
result = GetDistributionResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = GetDistributionResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
if let Some(e_tag) = response.headers.get("ETag") {
let value = e_tag.to_owned();
result.e_tag = Some(value)
};
Ok(result)
}))
})
}
#[allow(unused_variables, warnings)]
fn get_distribution_config(
&self,
input: GetDistributionConfigRequest,
) -> RusotoFuture<GetDistributionConfigResult, GetDistributionConfigError> {
let request_uri = format!("/2017-03-25/distribution/{id}/config", id = input.id);
let mut request = SignedRequest::new("GET", "cloudfront", &self.region, &request_uri);
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response.buffer().from_err().and_then(|response| {
Err(GetDistributionConfigError::from_response(response))
}),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let mut result;
if response.body.is_empty() {
result = GetDistributionConfigResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = GetDistributionConfigResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
if let Some(e_tag) = response.headers.get("ETag") {
let value = e_tag.to_owned();
result.e_tag = Some(value)
};
Ok(result)
}))
})
}
#[allow(unused_variables, warnings)]
fn get_invalidation(
&self,
input: GetInvalidationRequest,
) -> RusotoFuture<GetInvalidationResult, GetInvalidationError> {
let request_uri = format!(
"/2017-03-25/distribution/{distribution_id}/invalidation/{id}",
distribution_id = input.distribution_id,
id = input.id
);
let mut request = SignedRequest::new("GET", "cloudfront", &self.region, &request_uri);
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(GetInvalidationError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let mut result;
if response.body.is_empty() {
result = GetInvalidationResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = GetInvalidationResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
#[allow(unused_variables, warnings)]
fn get_streaming_distribution(
&self,
input: GetStreamingDistributionRequest,
) -> RusotoFuture<GetStreamingDistributionResult, GetStreamingDistributionError> {
let request_uri = format!("/2017-03-25/streaming-distribution/{id}", id = input.id);
let mut request = SignedRequest::new("GET", "cloudfront", &self.region, &request_uri);
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(GetStreamingDistributionError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let mut result;
if response.body.is_empty() {
result = GetStreamingDistributionResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = GetStreamingDistributionResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
if let Some(e_tag) = response.headers.get("ETag") {
let value = e_tag.to_owned();
result.e_tag = Some(value)
};
Ok(result)
}))
})
}
#[allow(unused_variables, warnings)]
fn get_streaming_distribution_config(
&self,
input: GetStreamingDistributionConfigRequest,
) -> RusotoFuture<GetStreamingDistributionConfigResult, GetStreamingDistributionConfigError>
{
let request_uri = format!(
"/2017-03-25/streaming-distribution/{id}/config",
id = input.id
);
let mut request = SignedRequest::new("GET", "cloudfront", &self.region, &request_uri);
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(GetStreamingDistributionConfigError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let mut result;
if response.body.is_empty() {
result = GetStreamingDistributionConfigResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = GetStreamingDistributionConfigResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
if let Some(e_tag) = response.headers.get("ETag") {
let value = e_tag.to_owned();
result.e_tag = Some(value)
};
Ok(result)
}))
})
}
#[allow(unused_variables, warnings)]
fn list_cloud_front_origin_access_identities(
&self,
input: ListCloudFrontOriginAccessIdentitiesRequest,
) -> RusotoFuture<
ListCloudFrontOriginAccessIdentitiesResult,
ListCloudFrontOriginAccessIdentitiesError,
> {
let request_uri = "/2017-03-25/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);
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(ListCloudFrontOriginAccessIdentitiesError::from_response(
response,
))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let mut result;
if response.body.is_empty() {
result = ListCloudFrontOriginAccessIdentitiesResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = ListCloudFrontOriginAccessIdentitiesResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
#[allow(unused_variables, warnings)]
fn list_distributions(
&self,
input: ListDistributionsRequest,
) -> RusotoFuture<ListDistributionsResult, ListDistributionsError> {
let request_uri = "/2017-03-25/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);
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(ListDistributionsError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let mut result;
if response.body.is_empty() {
result = ListDistributionsResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = ListDistributionsResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
#[allow(unused_variables, warnings)]
fn list_distributions_by_web_acl_id(
&self,
input: ListDistributionsByWebACLIdRequest,
) -> RusotoFuture<ListDistributionsByWebACLIdResult, ListDistributionsByWebACLIdError> {
let request_uri = format!(
"/2017-03-25/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);
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(ListDistributionsByWebACLIdError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let mut result;
if response.body.is_empty() {
result = ListDistributionsByWebACLIdResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = ListDistributionsByWebACLIdResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
#[allow(unused_variables, warnings)]
fn list_invalidations(
&self,
input: ListInvalidationsRequest,
) -> RusotoFuture<ListInvalidationsResult, ListInvalidationsError> {
let request_uri = format!(
"/2017-03-25/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);
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(ListInvalidationsError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let mut result;
if response.body.is_empty() {
result = ListInvalidationsResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = ListInvalidationsResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
#[allow(unused_variables, warnings)]
fn list_streaming_distributions(
&self,
input: ListStreamingDistributionsRequest,
) -> RusotoFuture<ListStreamingDistributionsResult, ListStreamingDistributionsError> {
let request_uri = "/2017-03-25/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);
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(ListStreamingDistributionsError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let mut result;
if response.body.is_empty() {
result = ListStreamingDistributionsResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = ListStreamingDistributionsResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
#[allow(unused_variables, warnings)]
fn list_tags_for_resource(
&self,
input: ListTagsForResourceRequest,
) -> RusotoFuture<ListTagsForResourceResult, ListTagsForResourceError> {
let request_uri = "/2017-03-25/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);
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response.buffer().from_err().and_then(|response| {
Err(ListTagsForResourceError::from_response(response))
}),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let mut result;
if response.body.is_empty() {
result = ListTagsForResourceResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = ListTagsForResourceResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
Ok(result)
}))
})
}
#[allow(unused_variables, warnings)]
fn tag_resource(&self, input: TagResourceRequest) -> RusotoFuture<(), TagResourceError> {
let request_uri = "/2017-03-25/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()));
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(TagResourceError::from_response(response))),
);
}
Box::new(future::ok(::std::mem::drop(response)))
})
}
#[allow(unused_variables, warnings)]
fn untag_resource(&self, input: UntagResourceRequest) -> RusotoFuture<(), UntagResourceError> {
let request_uri = "/2017-03-25/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()));
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(UntagResourceError::from_response(response))),
);
}
Box::new(future::ok(::std::mem::drop(response)))
})
}
#[allow(unused_variables, warnings)]
fn update_cloud_front_origin_access_identity(
&self,
input: UpdateCloudFrontOriginAccessIdentityRequest,
) -> RusotoFuture<
UpdateCloudFrontOriginAccessIdentityResult,
UpdateCloudFrontOriginAccessIdentityError,
> {
let request_uri = format!(
"/2017-03-25/origin-access-identity/cloudfront/{id}/config",
id = input.id
);
let mut request = SignedRequest::new("PUT", "cloudfront", &self.region, &request_uri);
if let Some(ref if_match) = input.if_match {
request.add_header("If-Match", &if_match.to_string());
}
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()));
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(UpdateCloudFrontOriginAccessIdentityError::from_response(
response,
))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let mut result;
if response.body.is_empty() {
result = UpdateCloudFrontOriginAccessIdentityResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = UpdateCloudFrontOriginAccessIdentityResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
if let Some(e_tag) = response.headers.get("ETag") {
let value = e_tag.to_owned();
result.e_tag = Some(value)
};
Ok(result)
}))
})
}
#[allow(unused_variables, warnings)]
fn update_distribution(
&self,
input: UpdateDistributionRequest,
) -> RusotoFuture<UpdateDistributionResult, UpdateDistributionError> {
let request_uri = format!("/2017-03-25/distribution/{id}/config", id = input.id);
let mut request = SignedRequest::new("PUT", "cloudfront", &self.region, &request_uri);
if let Some(ref if_match) = input.if_match {
request.add_header("If-Match", &if_match.to_string());
}
let mut writer = EventWriter::new(Vec::new());
DistributionConfigSerializer::serialize(
&mut writer,
"DistributionConfig",
&input.distribution_config,
);
request.set_payload(Some(writer.into_inner()));
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(UpdateDistributionError::from_response(response))),
);
}
Box::new(response.buffer().from_err().and_then(move |response| {
let mut result;
if response.body.is_empty() {
result = UpdateDistributionResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = UpdateDistributionResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
if let Some(e_tag) = response.headers.get("ETag") {
let value = e_tag.to_owned();
result.e_tag = Some(value)
};
Ok(result)
}))
})
}
#[allow(unused_variables, warnings)]
fn update_streaming_distribution(
&self,
input: UpdateStreamingDistributionRequest,
) -> RusotoFuture<UpdateStreamingDistributionResult, UpdateStreamingDistributionError> {
let request_uri = format!(
"/2017-03-25/streaming-distribution/{id}/config",
id = input.id
);
let mut request = SignedRequest::new("PUT", "cloudfront", &self.region, &request_uri);
if let Some(ref if_match) = input.if_match {
request.add_header("If-Match", &if_match.to_string());
}
let mut writer = EventWriter::new(Vec::new());
StreamingDistributionConfigSerializer::serialize(
&mut writer,
"StreamingDistributionConfig",
&input.streaming_distribution_config,
);
request.set_payload(Some(writer.into_inner()));
self.client.sign_and_dispatch(request, |response| {
if !response.status.is_success() {
return Box::new(response.buffer().from_err().and_then(|response| {
Err(UpdateStreamingDistributionError::from_response(response))
}));
}
Box::new(response.buffer().from_err().and_then(move |response| {
let mut result;
if response.body.is_empty() {
result = UpdateStreamingDistributionResult::default();
} else {
let reader = EventReader::new_with_config(
response.body.as_slice(),
ParserConfig::new().trim_whitespace(true),
);
let mut stack = XmlResponse::new(reader.into_iter().peekable());
let _start_document = stack.next();
let actual_tag_name = peek_at_name(&mut stack)?;
result = UpdateStreamingDistributionResultDeserializer::deserialize(
&actual_tag_name,
&mut stack,
)?;
}
if let Some(e_tag) = response.headers.get("ETag") {
let value = e_tag.to_owned();
result.e_tag = Some(value)
};
Ok(result)
}))
})
}
}
#[cfg(test)]
mod protocol_tests {
extern crate rusoto_mock;
use self::rusoto_mock::*;
use super::*;
use rusoto_core::Region as rusoto_region;
#[test]
fn test_parse_valid_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)
.sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
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).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
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).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
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).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
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)
.sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
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).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
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).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
#[test]
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).sync();
assert!(result.is_ok(), "parse error: {:?}", result);
}
}