Struct aws_sdk_ec2::model::UserIdGroupPair

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

Describes a security group and Amazon Web Services account ID pair.

We are retiring EC2-Classic. We recommend that you migrate from EC2-Classic to a VPC. For more information, see Migrate from EC2-Classic to a VPC in the Amazon Elastic Compute Cloud User Guide.

Implementations

impl UserIdGroupPair

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

A description for the security group rule that references this user ID group pair.

Constraints: Up to 255 characters in length. Allowed characters are a-z, A-Z, 0-9, spaces, and ._-:/()#,@[]+=;{}!$*

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

The ID of the security group.

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

The name of the security group. In a request, use this parameter for a security group in EC2-Classic or a default VPC only. For a security group in a nondefault VPC, use the security group ID.

For a referenced security group in another VPC, this value is not returned if the referenced security group is deleted.

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

The status of a VPC peering connection, if applicable.

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

The ID of an Amazon Web Services account.

For a referenced security group in another VPC, the account ID of the referenced security group is returned in the response. If the referenced security group is deleted, this value is not returned.

[EC2-Classic] Required when adding or removing rules that reference a security group in another Amazon Web Services account.

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

The ID of the VPC for the referenced security group, if applicable.

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

The ID of the VPC peering connection, if applicable.

impl UserIdGroupPair

pub fn builder() -> Builder

Creates a new builder-style object to manufacture UserIdGroupPair.

Examples found in repository

src/xml_deser.rs (line 66991)

pub fn deser_structure_crate_model_user_id_group_pair(
    decoder: &mut aws_smithy_xml::decode::ScopedDecoder,
) -> Result<crate::model::UserIdGroupPair, aws_smithy_xml::decode::XmlDecodeError> {
    #[allow(unused_mut)]
    let mut builder = crate::model::UserIdGroupPair::builder();
    while let Some(mut tag) = decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("description") /* Description com.amazonaws.ec2#UserIdGroupPair$Description */ =>  {
                let var_3292 =
                    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_description(var_3292);
            }
            ,
            s if s.matches("groupId") /* GroupId com.amazonaws.ec2#UserIdGroupPair$GroupId */ =>  {
                let var_3293 =
                    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_group_id(var_3293);
            }
            ,
            s if s.matches("groupName") /* GroupName com.amazonaws.ec2#UserIdGroupPair$GroupName */ =>  {
                let var_3294 =
                    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_group_name(var_3294);
            }
            ,
            s if s.matches("peeringStatus") /* PeeringStatus com.amazonaws.ec2#UserIdGroupPair$PeeringStatus */ =>  {
                let var_3295 =
                    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_peering_status(var_3295);
            }
            ,
            s if s.matches("userId") /* UserId com.amazonaws.ec2#UserIdGroupPair$UserId */ =>  {
                let var_3296 =
                    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_user_id(var_3296);
            }
            ,
            s if s.matches("vpcId") /* VpcId com.amazonaws.ec2#UserIdGroupPair$VpcId */ =>  {
                let var_3297 =
                    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_vpc_id(var_3297);
            }
            ,
            s if s.matches("vpcPeeringConnectionId") /* VpcPeeringConnectionId com.amazonaws.ec2#UserIdGroupPair$VpcPeeringConnectionId */ =>  {
                let var_3298 =
                    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_vpc_peering_connection_id(var_3298);
            }
            ,
            _ => {}
        }
    }
    Ok(builder.build())
}

Trait Implementations

impl Clone for UserIdGroupPair

fn clone(&self) -> UserIdGroupPair

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for UserIdGroupPair

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

Formats the value using the given formatter.

impl PartialEq<UserIdGroupPair> for UserIdGroupPair

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