Struct aws_sdk_s3control::model::AccessPoint

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

An access point used to access a bucket.

Implementations

impl AccessPoint

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

The name of this access point.

pub fn network_origin(&self) -> Option<&NetworkOrigin>

Indicates whether this access point allows access from the public internet. If VpcConfiguration is specified for this access point, then NetworkOrigin is VPC, and the access point doesn't allow access from the public internet. Otherwise, NetworkOrigin is Internet, and the access point allows access from the public internet, subject to the access point and bucket access policies.

pub fn vpc_configuration(&self) -> Option<&VpcConfiguration>

The virtual private cloud (VPC) configuration for this access point, if one exists.

This element is empty if this access point is an Amazon S3 on Outposts access point that is used by other Amazon Web Services.

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

The name of the bucket associated with this access point.

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

The ARN for the access point.

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

The name or alias of the access point.

impl AccessPoint

pub fn builder() -> Builder

Creates a new builder-style object to manufacture AccessPoint.

Examples found in repository

src/xml_deser.rs (line 3873)

pub fn deser_structure_crate_model_access_point(
    decoder: &mut aws_smithy_xml::decode::ScopedDecoder,
) -> Result<crate::model::AccessPoint, aws_smithy_xml::decode::XmlDecodeError> {
    #[allow(unused_mut)]
    let mut builder = crate::model::AccessPoint::builder();
    while let Some(mut tag) = decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("Name") /* Name com.amazonaws.s3control#AccessPoint$Name */ =>  {
                let var_167 =
                    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_name(var_167);
            }
            ,
            s if s.matches("NetworkOrigin") /* NetworkOrigin com.amazonaws.s3control#AccessPoint$NetworkOrigin */ =>  {
                let var_168 =
                    Some(
                        Result::<crate::model::NetworkOrigin, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            crate::model::NetworkOrigin::from(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                        )
                        ?
                    )
                ;
                builder = builder.set_network_origin(var_168);
            }
            ,
            s if s.matches("VpcConfiguration") /* VpcConfiguration com.amazonaws.s3control#AccessPoint$VpcConfiguration */ =>  {
                let var_169 =
                    Some(
                        crate::xml_deser::deser_structure_crate_model_vpc_configuration(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_vpc_configuration(var_169);
            }
            ,
            s if s.matches("Bucket") /* Bucket com.amazonaws.s3control#AccessPoint$Bucket */ =>  {
                let var_170 =
                    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_bucket(var_170);
            }
            ,
            s if s.matches("AccessPointArn") /* AccessPointArn com.amazonaws.s3control#AccessPoint$AccessPointArn */ =>  {
                let var_171 =
                    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_access_point_arn(var_171);
            }
            ,
            s if s.matches("Alias") /* Alias com.amazonaws.s3control#AccessPoint$Alias */ =>  {
                let var_172 =
                    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_alias(var_172);
            }
            ,
            _ => {}
        }
    }
    Ok(builder.build())
}

Trait Implementations

impl Clone for AccessPoint

fn clone(&self) -> AccessPoint

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for AccessPoint

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

Formats the value using the given formatter.

impl PartialEq<AccessPoint> for AccessPoint

fn eq(&self, other: &AccessPoint) -> 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 AccessPoint