Struct aws_sdk_ec2::model::SecurityGroupRule

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

Describes a security group rule.

Implementations

impl SecurityGroupRule

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

The ID of the security group rule.

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

The ID of the security group.

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

The ID of the Amazon Web Services account that owns the security group.

pub fn is_egress(&self) -> Option<bool>

Indicates whether the security group rule is an outbound rule.

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

The IP protocol name (tcp, udp, icmp, icmpv6) or number (see Protocol Numbers).

Use -1 to specify all protocols.

pub fn from_port(&self) -> Option<i32>

The start of port range for the TCP and UDP protocols, or an ICMP/ICMPv6 type. A value of -1 indicates all ICMP/ICMPv6 types. If you specify all ICMP/ICMPv6 types, you must specify all codes.

pub fn to_port(&self) -> Option<i32>

The end of port range for the TCP and UDP protocols, or an ICMP/ICMPv6 code. A value of -1 indicates all ICMP/ICMPv6 codes. If you specify all ICMP/ICMPv6 types, you must specify all codes.

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

The IPv4 CIDR range.

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

The IPv6 CIDR range.

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

The ID of the prefix list.

pub fn referenced_group_info(&self) -> Option<&ReferencedSecurityGroup>

Describes the security group that is referenced in the rule.

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

The security group rule description.

pub fn tags(&self) -> Option<&[Tag]>

The tags applied to the security group rule.

impl SecurityGroupRule

pub fn builder() -> Builder

Creates a new builder-style object to manufacture SecurityGroupRule.

Examples found in repository

src/xml_deser.rs (line 39472)

pub fn deser_structure_crate_model_security_group_rule(
    decoder: &mut aws_smithy_xml::decode::ScopedDecoder,
) -> Result<crate::model::SecurityGroupRule, aws_smithy_xml::decode::XmlDecodeError> {
    #[allow(unused_mut)]
    let mut builder = crate::model::SecurityGroupRule::builder();
    while let Some(mut tag) = decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("securityGroupRuleId") /* SecurityGroupRuleId com.amazonaws.ec2#SecurityGroupRule$SecurityGroupRuleId */ =>  {
                let var_1672 =
                    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_security_group_rule_id(var_1672);
            }
            ,
            s if s.matches("groupId") /* GroupId com.amazonaws.ec2#SecurityGroupRule$GroupId */ =>  {
                let var_1673 =
                    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_1673);
            }
            ,
            s if s.matches("groupOwnerId") /* GroupOwnerId com.amazonaws.ec2#SecurityGroupRule$GroupOwnerId */ =>  {
                let var_1674 =
                    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_owner_id(var_1674);
            }
            ,
            s if s.matches("isEgress") /* IsEgress com.amazonaws.ec2#SecurityGroupRule$IsEgress */ =>  {
                let var_1675 =
                    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.ec2#Boolean`)"))
                        }
                        ?
                    )
                ;
                builder = builder.set_is_egress(var_1675);
            }
            ,
            s if s.matches("ipProtocol") /* IpProtocol com.amazonaws.ec2#SecurityGroupRule$IpProtocol */ =>  {
                let var_1676 =
                    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_ip_protocol(var_1676);
            }
            ,
            s if s.matches("fromPort") /* FromPort com.amazonaws.ec2#SecurityGroupRule$FromPort */ =>  {
                let var_1677 =
                    Some(
                         {
                            <i32 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 (integer: `com.amazonaws.ec2#Integer`)"))
                        }
                        ?
                    )
                ;
                builder = builder.set_from_port(var_1677);
            }
            ,
            s if s.matches("toPort") /* ToPort com.amazonaws.ec2#SecurityGroupRule$ToPort */ =>  {
                let var_1678 =
                    Some(
                         {
                            <i32 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 (integer: `com.amazonaws.ec2#Integer`)"))
                        }
                        ?
                    )
                ;
                builder = builder.set_to_port(var_1678);
            }
            ,
            s if s.matches("cidrIpv4") /* CidrIpv4 com.amazonaws.ec2#SecurityGroupRule$CidrIpv4 */ =>  {
                let var_1679 =
                    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_cidr_ipv4(var_1679);
            }
            ,
            s if s.matches("cidrIpv6") /* CidrIpv6 com.amazonaws.ec2#SecurityGroupRule$CidrIpv6 */ =>  {
                let var_1680 =
                    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_cidr_ipv6(var_1680);
            }
            ,
            s if s.matches("prefixListId") /* PrefixListId com.amazonaws.ec2#SecurityGroupRule$PrefixListId */ =>  {
                let var_1681 =
                    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_prefix_list_id(var_1681);
            }
            ,
            s if s.matches("referencedGroupInfo") /* ReferencedGroupInfo com.amazonaws.ec2#SecurityGroupRule$ReferencedGroupInfo */ =>  {
                let var_1682 =
                    Some(
                        crate::xml_deser::deser_structure_crate_model_referenced_security_group(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_referenced_group_info(var_1682);
            }
            ,
            s if s.matches("description") /* Description com.amazonaws.ec2#SecurityGroupRule$Description */ =>  {
                let var_1683 =
                    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_1683);
            }
            ,
            s if s.matches("tagSet") /* Tags com.amazonaws.ec2#SecurityGroupRule$Tags */ =>  {
                let var_1684 =
                    Some(
                        crate::xml_deser::deser_list_com_amazonaws_ec2_tag_list(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_tags(var_1684);
            }
            ,
            _ => {}
        }
    }
    Ok(builder.build())
}

Trait Implementations

impl Clone for SecurityGroupRule

fn clone(&self) -> SecurityGroupRule

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for SecurityGroupRule

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

Formats the value using the given formatter.

impl PartialEq<SecurityGroupRule> for SecurityGroupRule

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