Interface MatchEntryValueGrouping

  • All Superinterfaces:
    org.opendaylight.yangtools.yang.binding.BindingObject, org.opendaylight.yangtools.yang.binding.DataContainer, org.opendaylight.yangtools.yang.binding.DataObject
    All Known Subinterfaces:
    MatchEntry, OxmContainer

    @Generated("mdsal-binding-generator")
    public interface MatchEntryValueGrouping
    extends org.opendaylight.yangtools.yang.binding.DataObject

    This class represents the following YANG schema fragment defined in module openflow-extensible-match

     grouping match-entry-value-grouping {
       choice match-entry-value {
         case in-port-case {
           container in-port {
             leaf port-number {
               type oft:port-number;
             }
           }
         }
         case in-phy-port-case {
           container in-phy-port {
             leaf port-number {
               type oft:port-number;
             }
           }
         }
         case metadata-case {
           container metadata {
             leaf metadata {
               type binary;
             }
             leaf mask {
               type binary;
             }
           }
         }
         case packet-type-case {
           container packet-type {
             leaf packet-type {
               type uint32;
             }
           }
         }
         case eth-src-case {
           container eth-src {
             leaf mac-address {
               type yang:mac-address;
             }
             leaf mask {
               type binary;
             }
           }
         }
         case eth-dst-case {
           container eth-dst {
             leaf mac-address {
               type yang:mac-address;
             }
             leaf mask {
               type binary;
             }
           }
         }
         case eth-type-case {
           container eth-type {
             leaf eth-type {
               type oft:ether-type;
             }
           }
         }
         case vlan-vid-case {
           container vlan-vid {
             leaf vlan-vid {
               type uint16;
             }
             leaf cfi-bit {
               type boolean;
             }
             leaf mask {
               type binary;
             }
           }
         }
         case vlan-pcp-case {
           container vlan-pcp {
             leaf vlan-pcp {
               type uint8;
             }
           }
         }
         case ip-dscp-case {
           container ip-dscp {
             leaf dscp {
               type inet:dscp;
             }
           }
         }
         case ip-ecn-case {
           container ip-ecn {
             leaf ecn {
               type uint8;
             }
           }
         }
         case ip-proto-case {
           container ip-proto {
             leaf protocol-number {
               type uint8;
             }
           }
         }
         case ipv4-src-case {
           container ipv4-src {
             leaf ipv4-address {
               type inet:ipv4-address;
             }
             leaf mask {
               type binary;
             }
           }
         }
         case ipv4-dst-case {
           container ipv4-dst {
             leaf ipv4-address {
               type inet:ipv4-address;
             }
             leaf mask {
               type binary;
             }
           }
         }
         case tcp-src-case {
           container tcp-src {
             leaf port {
               type inet:port-number;
             }
           }
         }
         case tcp-dst-case {
           container tcp-dst {
             leaf port {
               type inet:port-number;
             }
           }
         }
         case udp-src-case {
           container udp-src {
             leaf port {
               type inet:port-number;
             }
           }
         }
         case udp-dst-case {
           container udp-dst {
             leaf port {
               type inet:port-number;
             }
           }
         }
         case sctp-src-case {
           container sctp-src {
             leaf port {
               type inet:port-number;
             }
           }
         }
         case sctp-dst-case {
           container sctp-dst {
             leaf port {
               type inet:port-number;
             }
           }
         }
         case icmpv4-type-case {
           container icmpv4-type {
             leaf icmpv4-type {
               type uint8;
             }
           }
         }
         case icmpv4-code-case {
           container icmpv4-code {
             leaf icmpv4-code {
               type uint8;
             }
           }
         }
         case arp-op-case {
           container arp-op {
             leaf op-code {
               type uint16;
             }
           }
         }
         case icmpv6-nd-reserved-case {
           container icmpv6-nd-reserved {
             leaf icmpv6-nd-reserved {
               type uint32;
             }
           }
         }
         case icmpv6-nd-options-type-case {
           container icmpv6-nd-options-type {
             leaf icmpv6-nd-options-type {
               type uint8;
             }
           }
         }
         case arp-spa-case {
           container arp-spa {
             leaf ipv4-address {
               type inet:ipv4-address;
             }
             leaf mask {
               type binary;
             }
           }
         }
         case arp-tpa-case {
           container arp-tpa {
             leaf ipv4-address {
               type inet:ipv4-address;
             }
             leaf mask {
               type binary;
             }
           }
         }
         case arp-sha-case {
           container arp-sha {
             leaf mac-address {
               type yang:mac-address;
             }
             leaf mask {
               type binary;
             }
           }
         }
         case arp-tha-case {
           container arp-tha {
             leaf mac-address {
               type yang:mac-address;
             }
             leaf mask {
               type binary;
             }
           }
         }
         case ipv6-src-case {
           container ipv6-src {
             leaf ipv6-address {
               type inet:ipv6-address;
             }
             leaf mask {
               type binary;
             }
           }
         }
         case ipv6-dst-case {
           container ipv6-dst {
             leaf ipv6-address {
               type inet:ipv6-address;
             }
             leaf mask {
               type binary;
             }
           }
         }
         case ipv6-flabel-case {
           container ipv6-flabel {
             leaf ipv6-flabel {
               type inet:ipv6-flow-label;
             }
             leaf mask {
               type binary;
             }
           }
         }
         case icmpv6-type-case {
           container icmpv6-type {
             leaf icmpv6-type {
               type uint8;
             }
           }
         }
         case icmpv6-code-case {
           container icmpv6-code {
             leaf icmpv6-code {
               type uint8;
             }
           }
         }
         case ipv6-nd-target-case {
           container ipv6-nd-target {
             leaf ipv6-address {
               type inet:ipv6-address;
             }
           }
         }
         case ipv6-nd-sll-case {
           container ipv6-nd-sll {
             leaf mac-address {
               type yang:mac-address;
             }
           }
         }
         case ipv6-nd-tll-case {
           container ipv6-nd-tll {
             leaf mac-address {
               type yang:mac-address;
             }
           }
         }
         case mpls-label-case {
           container mpls-label {
             leaf mpls-label {
               type uint32;
             }
           }
         }
         case mpls-tc-case {
           container mpls-tc {
             leaf tc {
               type uint8;
             }
           }
         }
         case mpls-bos-case {
           container mpls-bos {
             leaf bos {
               type boolean;
             }
           }
         }
         case pbb-isid-case {
           container pbb-isid {
             leaf isid {
               type uint32;
             }
             leaf mask {
               type binary;
             }
           }
         }
         case tunnel-id-case {
           container tunnel-id {
             leaf tunnel-id {
               type binary;
             }
             leaf mask {
               type binary;
             }
           }
         }
         case ipv6-exthdr-case {
           container ipv6-exthdr {
             leaf pseudo-field {
               type oft:ipv6-exthdr-flags;
             }
             leaf mask {
               type binary;
             }
           }
         }
       }
     }
     
    The schema path to identify an instance is openflow-extensible-match/match-entry-value-grouping
    • Field Detail

      • QNAME

        static final @NonNull org.opendaylight.yangtools.yang.common.QName QNAME
    • Method Detail

      • implementedInterface

        Class<? extends MatchEntryValueGrouping> implementedInterface()
        Specified by:
        implementedInterface in interface org.opendaylight.yangtools.yang.binding.DataContainer
        Specified by:
        implementedInterface in interface org.opendaylight.yangtools.yang.binding.DataObject
      • getMatchEntryValue

        MatchEntryValue getMatchEntryValue()
        Return matchEntryValue, or null if it is not present.
        Returns:
        org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.match.entry.value.grouping.MatchEntryValue matchEntryValue, or null if it is not present.