Struct aws_sdk_s3control::model::S3CopyObjectOperation

#[non_exhaustive]
pub struct S3CopyObjectOperation { /* private fields */ }

Contains the configuration parameters for a PUT Copy object operation. S3 Batch Operations passes every object to the underlying PUT Copy object API. For more information about the parameters for this operation, see PUT Object - Copy.

Implementations

impl S3CopyObjectOperation

pub fn target_resource(&self) -> Option<&str>

Specifies the destination bucket ARN for the batch copy operation. For example, to copy objects to a bucket named "destinationBucket", set the TargetResource to "arn:aws:s3:::destinationBucket".

pub fn canned_access_control_list(&self) -> Option<&S3CannedAccessControlList>

pub fn access_control_grants(&self) -> Option<&[S3Grant]>

pub fn metadata_directive(&self) -> Option<&S3MetadataDirective>

pub fn modified_since_constraint(&self) -> Option<&DateTime>

pub fn new_object_metadata(&self) -> Option<&S3ObjectMetadata>

If you don't provide this parameter, Amazon S3 copies all the metadata from the original objects. If you specify an empty set, the new objects will have no tags. Otherwise, Amazon S3 assigns the supplied tags to the new objects.

pub fn new_object_tagging(&self) -> Option<&[S3Tag]>

pub fn redirect_location(&self) -> Option<&str>

Specifies an optional metadata property for website redirects, x-amz-website-redirect-location. Allows webpage redirects if the object is accessed through a website endpoint.

pub fn requester_pays(&self) -> bool

pub fn storage_class(&self) -> Option<&S3StorageClass>

pub fn un_modified_since_constraint(&self) -> Option<&DateTime>

pub fn sse_aws_kms_key_id(&self) -> Option<&str>

pub fn target_key_prefix(&self) -> Option<&str>

Specifies the folder prefix into which you would like the objects to be copied. For example, to copy objects into a folder named Folder1 in the destination bucket, set the TargetKeyPrefix to Folder1.

pub fn object_lock_legal_hold_status(
    &self
) -> Option<&S3ObjectLockLegalHoldStatus>

The legal hold status to be applied to all objects in the Batch Operations job.

pub fn object_lock_mode(&self) -> Option<&S3ObjectLockMode>

The retention mode to be applied to all objects in the Batch Operations job.

pub fn object_lock_retain_until_date(&self) -> Option<&DateTime>

The date when the applied object retention configuration expires on all objects in the Batch Operations job.

pub fn bucket_key_enabled(&self) -> bool

Specifies whether Amazon S3 should use an S3 Bucket Key for object encryption with server-side encryption using Amazon Web Services KMS (SSE-KMS). Setting this header to true causes Amazon S3 to use an S3 Bucket Key for object encryption with SSE-KMS.

Specifying this header with an object action doesn’t affect bucket-level settings for S3 Bucket Key.

pub fn checksum_algorithm(&self) -> Option<&S3ChecksumAlgorithm>

Indicates the algorithm you want Amazon S3 to use to create the checksum. For more information see Checking object integrity in the Amazon S3 User Guide.

impl S3CopyObjectOperation

pub fn builder() -> Builder

Creates a new builder-style object to manufacture S3CopyObjectOperation.

Examples found in repository

src/xml_deser.rs (line 4475)

pub fn deser_structure_crate_model_s3_copy_object_operation(
    decoder: &mut aws_smithy_xml::decode::ScopedDecoder,
) -> Result<crate::model::S3CopyObjectOperation, aws_smithy_xml::decode::XmlDecodeError> {
    #[allow(unused_mut)]
    let mut builder = crate::model::S3CopyObjectOperation::builder();
    while let Some(mut tag) = decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("TargetResource") /* TargetResource com.amazonaws.s3control#S3CopyObjectOperation$TargetResource */ =>  {
                let var_203 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_target_resource(var_203);
            }
            ,
            s if s.matches("CannedAccessControlList") /* CannedAccessControlList com.amazonaws.s3control#S3CopyObjectOperation$CannedAccessControlList */ =>  {
                let var_204 =
                    Some(
                        Result::<crate::model::S3CannedAccessControlList, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            crate::model::S3CannedAccessControlList::from(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                        )
                        ?
                    )
                ;
                builder = builder.set_canned_access_control_list(var_204);
            }
            ,
            s if s.matches("AccessControlGrants") /* AccessControlGrants com.amazonaws.s3control#S3CopyObjectOperation$AccessControlGrants */ =>  {
                let var_205 =
                    Some(
                        crate::xml_deser::deser_list_com_amazonaws_s3control_s3_grant_list(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_access_control_grants(var_205);
            }
            ,
            s if s.matches("MetadataDirective") /* MetadataDirective com.amazonaws.s3control#S3CopyObjectOperation$MetadataDirective */ =>  {
                let var_206 =
                    Some(
                        Result::<crate::model::S3MetadataDirective, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            crate::model::S3MetadataDirective::from(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                        )
                        ?
                    )
                ;
                builder = builder.set_metadata_directive(var_206);
            }
            ,
            s if s.matches("ModifiedSinceConstraint") /* ModifiedSinceConstraint com.amazonaws.s3control#S3CopyObjectOperation$ModifiedSinceConstraint */ =>  {
                let var_207 =
                    Some(
                        aws_smithy_types::DateTime::from_str(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            , aws_smithy_types::date_time::Format::DateTime
                        )
                        .map_err(|_|aws_smithy_xml::decode::XmlDecodeError::custom("expected (timestamp: `com.amazonaws.s3control#TimeStamp`)"))
                        ?
                    )
                ;
                builder = builder.set_modified_since_constraint(var_207);
            }
            ,
            s if s.matches("NewObjectMetadata") /* NewObjectMetadata com.amazonaws.s3control#S3CopyObjectOperation$NewObjectMetadata */ =>  {
                let var_208 =
                    Some(
                        crate::xml_deser::deser_structure_crate_model_s3_object_metadata(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_new_object_metadata(var_208);
            }
            ,
            s if s.matches("NewObjectTagging") /* NewObjectTagging com.amazonaws.s3control#S3CopyObjectOperation$NewObjectTagging */ =>  {
                let var_209 =
                    Some(
                        crate::xml_deser::deser_list_com_amazonaws_s3control_s3_tag_set(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_new_object_tagging(var_209);
            }
            ,
            s if s.matches("RedirectLocation") /* RedirectLocation com.amazonaws.s3control#S3CopyObjectOperation$RedirectLocation */ =>  {
                let var_210 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_redirect_location(var_210);
            }
            ,
            s if s.matches("RequesterPays") /* RequesterPays com.amazonaws.s3control#S3CopyObjectOperation$RequesterPays */ =>  {
                let var_211 =
                    Some(
                         {
                            <bool as aws_smithy_types::primitive::Parse>::parse_smithy_primitive(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                            .map_err(|_|aws_smithy_xml::decode::XmlDecodeError::custom("expected (boolean: `com.amazonaws.s3control#Boolean`)"))
                        }
                        ?
                    )
                ;
                builder = builder.set_requester_pays(var_211);
            }
            ,
            s if s.matches("StorageClass") /* StorageClass com.amazonaws.s3control#S3CopyObjectOperation$StorageClass */ =>  {
                let var_212 =
                    Some(
                        Result::<crate::model::S3StorageClass, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            crate::model::S3StorageClass::from(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                        )
                        ?
                    )
                ;
                builder = builder.set_storage_class(var_212);
            }
            ,
            s if s.matches("UnModifiedSinceConstraint") /* UnModifiedSinceConstraint com.amazonaws.s3control#S3CopyObjectOperation$UnModifiedSinceConstraint */ =>  {
                let var_213 =
                    Some(
                        aws_smithy_types::DateTime::from_str(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            , aws_smithy_types::date_time::Format::DateTime
                        )
                        .map_err(|_|aws_smithy_xml::decode::XmlDecodeError::custom("expected (timestamp: `com.amazonaws.s3control#TimeStamp`)"))
                        ?
                    )
                ;
                builder = builder.set_un_modified_since_constraint(var_213);
            }
            ,
            s if s.matches("SSEAwsKmsKeyId") /* SSEAwsKmsKeyId com.amazonaws.s3control#S3CopyObjectOperation$SSEAwsKmsKeyId */ =>  {
                let var_214 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_sse_aws_kms_key_id(var_214);
            }
            ,
            s if s.matches("TargetKeyPrefix") /* TargetKeyPrefix com.amazonaws.s3control#S3CopyObjectOperation$TargetKeyPrefix */ =>  {
                let var_215 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_target_key_prefix(var_215);
            }
            ,
            s if s.matches("ObjectLockLegalHoldStatus") /* ObjectLockLegalHoldStatus com.amazonaws.s3control#S3CopyObjectOperation$ObjectLockLegalHoldStatus */ =>  {
                let var_216 =
                    Some(
                        Result::<crate::model::S3ObjectLockLegalHoldStatus, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            crate::model::S3ObjectLockLegalHoldStatus::from(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                        )
                        ?
                    )
                ;
                builder = builder.set_object_lock_legal_hold_status(var_216);
            }
            ,
            s if s.matches("ObjectLockMode") /* ObjectLockMode com.amazonaws.s3control#S3CopyObjectOperation$ObjectLockMode */ =>  {
                let var_217 =
                    Some(
                        Result::<crate::model::S3ObjectLockMode, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            crate::model::S3ObjectLockMode::from(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                        )
                        ?
                    )
                ;
                builder = builder.set_object_lock_mode(var_217);
            }
            ,
            s if s.matches("ObjectLockRetainUntilDate") /* ObjectLockRetainUntilDate com.amazonaws.s3control#S3CopyObjectOperation$ObjectLockRetainUntilDate */ =>  {
                let var_218 =
                    Some(
                        aws_smithy_types::DateTime::from_str(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            , aws_smithy_types::date_time::Format::DateTime
                        )
                        .map_err(|_|aws_smithy_xml::decode::XmlDecodeError::custom("expected (timestamp: `com.amazonaws.s3control#TimeStamp`)"))
                        ?
                    )
                ;
                builder = builder.set_object_lock_retain_until_date(var_218);
            }
            ,
            s if s.matches("BucketKeyEnabled") /* BucketKeyEnabled com.amazonaws.s3control#S3CopyObjectOperation$BucketKeyEnabled */ =>  {
                let var_219 =
                    Some(
                         {
                            <bool as aws_smithy_types::primitive::Parse>::parse_smithy_primitive(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                            .map_err(|_|aws_smithy_xml::decode::XmlDecodeError::custom("expected (boolean: `com.amazonaws.s3control#Boolean`)"))
                        }
                        ?
                    )
                ;
                builder = builder.set_bucket_key_enabled(var_219);
            }
            ,
            s if s.matches("ChecksumAlgorithm") /* ChecksumAlgorithm com.amazonaws.s3control#S3CopyObjectOperation$ChecksumAlgorithm */ =>  {
                let var_220 =
                    Some(
                        Result::<crate::model::S3ChecksumAlgorithm, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            crate::model::S3ChecksumAlgorithm::from(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                        )
                        ?
                    )
                ;
                builder = builder.set_checksum_algorithm(var_220);
            }
            ,
            _ => {}
        }
    }
    Ok(builder.build())
}

Trait Implementations

impl Clone for S3CopyObjectOperation

fn clone(&self) -> S3CopyObjectOperation

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for S3CopyObjectOperation

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq<S3CopyObjectOperation> for S3CopyObjectOperation

fn eq(&self, other: &S3CopyObjectOperation) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for S3CopyObjectOperation