All Superinterfaces:: org.opendaylight.yangtools.yang.binding.DataRoot

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

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

 module openflow-extensible-match {
   namespace urn:opendaylight:openflow:oxm;
   prefix oxm;
   import ietf-yang-types {
     prefix yang;
   }
   import ietf-inet-types {
     prefix inet;
   }
   import openflow-types {
     prefix oft;
   }
   revision 2015-02-25 {
   }
   identity oxm-match-type {
     base match-type-base;
   }
   identity oxm-class-base {
   }
   identity nxm-0-class {
     base oxm-class-base;
   }
   identity nxm-1-class {
     base oxm-class-base;
   }
   identity eric-exp-class {
     base oxm-class-base;
   }
   identity openflow-basic-class {
     base oxm-class-base;
   }
   identity experimenter-class {
     base oxm-class-base;
   }
   identity match-field {
   }
   identity in_port {
     base match-field;
   }
   identity in_phy_port {
     base match-field;
   }
   identity metadata {
     base match-field;
   }
   identity packet_type {
     base match-field;
   }
   identity eth_dst {
     base match-field;
   }
   identity eth_src {
     base match-field;
   }
   identity eth_type {
     base match-field;
   }
   identity vlan_vid {
     base match-field;
   }
   identity vlan_pcp {
     base match-field;
   }
   identity ip_dscp {
     base match-field;
   }
   identity ip_ecn {
     base match-field;
   }
   identity ip_proto {
     base match-field;
   }
   identity ipv4_src {
     base match-field;
   }
   identity ipv4_dst {
     base match-field;
   }
   identity tcp_src {
     base match-field;
   }
   identity tcp_dst {
     base match-field;
   }
   identity udp_src {
     base match-field;
   }
   identity udp_dst {
     base match-field;
   }
   identity sctp_src {
     base match-field;
   }
   identity sctp_dst {
     base match-field;
   }
   identity icmpv4_type {
     base match-field;
   }
   identity icmpv4_code {
     base match-field;
   }
   identity arp_op {
     base match-field;
   }
   identity arp_spa {
     base match-field;
   }
   identity arp_tpa {
     base match-field;
   }
   identity arp_sha {
     base match-field;
   }
   identity arp_tha {
     base match-field;
   }
   identity ipv6_src {
     base match-field;
   }
   identity ipv6_dst {
     base match-field;
   }
   identity ipv6_flabel {
     base match-field;
   }
   identity icmpv6_type {
     base match-field;
   }
   identity icmpv6_code {
     base match-field;
   }
   identity ipv6_nd_target {
     base match-field;
   }
   identity ipv6_nd_sll {
     base match-field;
   }
   identity ipv6_nd_tll {
     base match-field;
   }
   identity mpls_label {
     base match-field;
   }
   identity mpls_tc {
     base match-field;
   }
   identity mpls_bos {
     base match-field;
   }
   identity pbb_isid {
     base match-field;
   }
   identity tunnel_id {
     base match-field;
   }
   identity ipv6_exthdr {
     base match-field;
   }
   grouping match-grouping {
     container match {
       leaf type {
         type identityref {
           base match-type-base;
         }
       }
       uses match-entries-grouping;
     }
   }
   grouping match-entries-grouping {
     list match-entry {
       config false;
       uses match-entry-fields-grouping;
       uses match-entry-value-grouping;
     }
   }
   grouping match-entry-fields-grouping {
     leaf oxm-class {
       type identityref {
         base oxm-class-base;
       }
     }
     leaf oxm-match-field {
       type identityref {
         base match-field;
       }
     }
     leaf has-mask {
       type boolean;
     }
   }
   container oxm-container {
     uses match-entry-value-grouping;
   }
   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;
           }
         }
       }
     }
   }
   grouping match-v10-grouping {
     container match-v10 {
       leaf wildcards {
         type oft:flow-wildcards-v10;
       }
       leaf nw-src-mask {
         type uint8;
       }
       leaf nw-dst-mask {
         type uint8;
       }
       leaf in-port {
         type uint16;
       }
       leaf dl-src {
         type yang:mac-address;
       }
       leaf dl-dst {
         type yang:mac-address;
       }
       leaf dl-vlan {
         type uint16;
       }
       leaf dl-vlan-pcp {
         type uint8;
       }
       leaf dl-type {
         type uint16;
       }
       leaf nw-tos {
         type uint8;
       }
       leaf nw-proto {
         type uint8;
       }
       leaf nw-src {
         type inet:ipv4-address;
       }
       leaf nw-dst {
         type inet:ipv4-address;
       }
       leaf tp-src {
         type uint16;
       }
       leaf tp-dst {
         type uint16;
       }
     }
   }
 }

- Method Summary
  
  All Methods Instance Methods Abstract Methods
  Modifier and Type Method Description
  
  OxmContainer getOxmContainer()
  Return oxmContainer, or null if it is not present.

- Method Detail
  - getOxmContainer
```
OxmContainer getOxmContainer()
```
    Return oxmContainer, or null if it is not present.
    
    Returns:
    
    OxmContainer oxmContainer, or null if it is not present.

Interface OpenflowExtensibleMatchData

Method Summary

Method Detail

getOxmContainer