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

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

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

 module openflow-protocol {
   namespace urn:opendaylight:openflow:protocol;
   prefix ofproto;
   import ietf-yang-types {
     prefix yang;
   }
   import openflow-types {
     prefix oft;
   }
   import openflow-extensible-match {
     prefix oxm;
   }
   import openflow-instruction {
     prefix ofinstruction;
   }
   import openflow-action {
     prefix ofaction;
   }
   revision 2013-07-31 {
   }
   grouping port-grouping {
     leaf port-no {
       type uint32;
     }
     leaf hw-addr {
       type yang:mac-address;
     }
     leaf name {
       type string;
     }
     leaf config {
       type oft:port-config;
     }
     leaf state {
       type oft:port-state;
     }
     leaf current-features {
       type oft:port-features;
     }
     leaf advertised-features {
       type oft:port-features;
     }
     leaf supported-features {
       type oft:port-features;
     }
     leaf peer-features {
       type oft:port-features;
     }
     leaf curr-speed {
       type uint32;
       units kbps;
     }
     leaf max-speed {
       type uint32;
       units kbps;
     }
     leaf config-v10 {
       type oft:port-config-v10;
     }
     leaf state-v10 {
       type oft:port-state-v10;
     }
     leaf current-features-v10 {
       type oft:port-features-v10;
     }
     leaf advertised-features-v10 {
       type oft:port-features-v10;
     }
     leaf supported-features-v10 {
       type oft:port-features-v10;
     }
     leaf peer-features-v10 {
       type oft:port-features-v10;
     }
   }
   grouping buckets-grouping {
     list buckets-list {
       uses bucket-grouping;
     }
   }
   grouping bucket-grouping {
     leaf weight {
       type uint16;
     }
     leaf watch-port {
       type oft:port-number;
     }
     leaf watch-group {
       type uint32;
     }
     uses ofaction:actions-grouping;
   }
   container table-features-properties-container {
     uses table-features-properties-grouping;
   }
   grouping table-features-properties-grouping {
     list table-feature-properties {
       config false;
       leaf type {
         type oft:table-features-prop-type;
       }
     }
   }
   grouping ofHeader {
     leaf version {
       type uint8;
     }
     leaf xid {
       type uint32;
     }
   }
   grouping ofHelloElementHeader {
     leaf type {
       type oft:hello-element-type;
     }
   }
   grouping hello {
     uses ofHeader;
     list elements {
       uses ofHelloElementHeader;
       leaf-list version-bitmap {
         type boolean;
       }
     }
   }
   grouping error {
     uses ofHeader;
     leaf type {
       type uint16;
     }
     leaf code {
       type uint16;
     }
     leaf type-string {
       type string;
     }
     leaf code-string {
       type string;
     }
     leaf data {
       type binary;
     }
   }
   grouping echo-request {
     uses ofHeader;
     leaf data {
       type binary;
     }
   }
   grouping echo-reply {
     uses ofHeader;
     leaf data {
       type binary;
     }
   }
   grouping experimenter-core {
     leaf experimenter {
       type oft:experimenter-id;
     }
     leaf exp_type {
       type uint32;
     }
     choice experimenter-data-of-choice;
   }
   grouping experimenter-of-message {
     uses ofHeader;
     uses experimenter-core;
   }
   grouping features-request {
     uses ofHeader;
   }
   grouping features-reply {
     uses ofHeader;
     leaf datapathId {
       type uint64;
     }
     leaf buffers {
       type uint32;
     }
     leaf tables {
       type uint8;
     }
     leaf auxiliaryId {
       type uint8;
     }
     leaf capabilities {
       type oft:capabilities;
     }
     leaf reserved {
       type uint32;
     }
     leaf capabilities-v10 {
       type oft:capabilities-v10;
     }
     leaf actions-v10 {
       type oft:action-type-v10;
     }
     list phy-port {
       uses port-grouping;
     }
   }
   grouping get-config-request {
     uses ofHeader;
   }
   grouping get-config-reply {
     uses ofHeader;
     leaf flags {
       type oft:switch-config-flag;
     }
     leaf miss-send-len {
       type uint16;
     }
   }
   grouping set-config {
     uses ofHeader;
     leaf flags {
       type oft:switch-config-flag;
     }
     leaf miss-send-len {
       type uint16;
     }
   }
   grouping packet-in {
     uses ofHeader;
     leaf buffer-id {
       type uint32;
     }
     leaf total-len {
       type uint16;
     }
     leaf reason {
       type oft:packet-in-reason;
     }
     leaf table-id {
       type oft:table-id;
     }
     leaf cookie {
       type uint64;
     }
     uses oxm:match-grouping;
     leaf data {
       type binary;
     }
     leaf in-port {
       type uint16;
     }
   }
   grouping flow-removed {
     uses ofHeader;
     leaf cookie {
       type uint64;
     }
     leaf priority {
       type uint16;
     }
     leaf reason {
       type oft:flow-removed-reason;
     }
     leaf table-id {
       type oft:table-id;
     }
     leaf duration-sec {
       type uint32;
     }
     leaf duration-nsec {
       type uint32;
     }
     leaf idle-timeout {
       type uint16;
     }
     leaf hard-timeout {
       type uint16;
     }
     leaf packet-count {
       type uint64;
     }
     leaf byte-count {
       type uint64;
     }
     uses oxm:match-grouping;
     uses oxm:match-v10-grouping;
   }
   grouping port-status {
     uses ofHeader;
     uses port-grouping;
     leaf reason {
       type oft:port-reason;
     }
   }
   grouping packet-out {
     uses ofHeader;
     uses ofaction:actions-grouping;
     leaf data {
       type binary;
     }
     leaf buffer-id {
       type uint32;
     }
     leaf in-port {
       type oft:port-number;
     }
   }
   grouping flow-mod {
     uses ofHeader;
     leaf cookie {
       type uint64;
     }
     leaf cookie-mask {
       type uint64;
     }
     leaf table-id {
       type oft:table-id;
     }
     leaf command {
       type oft:flow-mod-command;
     }
     leaf idle-timeout {
       type uint16;
     }
     leaf hard-timeout {
       type uint16;
     }
     leaf priority {
       type uint16;
     }
     leaf buffer-id {
       type uint32;
     }
     leaf out-port {
       type oft:port-number;
     }
     leaf out-group {
       type uint32;
     }
     leaf flags {
       type oft:flow-mod-flags;
     }
     uses oxm:match-grouping;
     uses ofinstruction:instructions-grouping;
     leaf flags-v10 {
       type oft:flow-mod-flags-v10;
     }
     uses oxm:match-v10-grouping;
     uses ofaction:actions-grouping;
   }
   grouping group-mod {
     uses ofHeader;
     leaf command {
       type oft:group-mod-command;
     }
     leaf type {
       type oft:group-type;
     }
     leaf group-id {
       type oft:group-id;
     }
     uses buckets-grouping;
   }
   grouping port-mod {
     uses ofHeader;
     leaf port-no {
       type oft:port-number;
     }
     leaf hw-address {
       type yang:mac-address;
     }
     leaf config {
       type oft:port-config;
     }
     leaf mask {
       type oft:port-config;
     }
     leaf advertise {
       type oft:port-features;
     }
     leaf config-v10 {
       type oft:port-config-v10;
     }
     leaf mask-v10 {
       type oft:port-config-v10;
     }
     leaf advertise-v10 {
       type oft:port-features-v10;
     }
   }
   grouping table-mod {
     uses ofHeader;
     leaf table-id {
       type oft:table-id;
     }
     leaf config {
       type oft:table-config;
     }
   }
   grouping multipart-request {
     uses ofHeader;
     leaf type {
       type oft:multipart-type;
     }
     leaf flags {
       type oft:multipart-request-flags;
     }
     choice multipart-request-body {
       case multipart-request-desc-case {
         container multipart-request-desc {
           leaf empty {
             type empty;
           }
         }
       }
       case multipart-request-flow-case {
         container multipart-request-flow {
           leaf table-id {
             type uint8;
           }
           leaf out-port {
             type uint32;
           }
           leaf out-group {
             type uint32;
           }
           leaf cookie {
             type uint64;
           }
           leaf cookie-mask {
             type uint64;
           }
           uses oxm:match-grouping;
           uses oxm:match-v10-grouping;
         }
       }
       case multipart-request-aggregate-case {
         container multipart-request-aggregate {
           leaf table-id {
             type uint8;
           }
           leaf out-port {
             type uint32;
           }
           leaf out-group {
             type uint32;
           }
           leaf cookie {
             type uint64;
           }
           leaf cookie-mask {
             type uint64;
           }
           uses oxm:match-grouping;
           uses oxm:match-v10-grouping;
         }
       }
       case multipart-request-table-case {
         container multipart-request-table {
           leaf empty {
             type empty;
           }
         }
       }
       case multipart-request-port-stats-case {
         container multipart-request-port-stats {
           leaf port-no {
             type uint32;
           }
         }
       }
       case multipart-request-queue-case {
         container multipart-request-queue {
           leaf port-no {
             type uint32;
           }
           leaf queue-id {
             type uint32;
           }
         }
       }
       case multipart-request-group-case {
         container multipart-request-group {
           leaf group-id {
             type oft:group-id;
           }
         }
       }
       case multipart-request-group-desc-case {
         container multipart-request-group-desc {
           leaf empty {
             type empty;
           }
         }
       }
       case multipart-request-group-features-case {
         container multipart-request-group-features {
           leaf empty {
             type empty;
           }
         }
       }
       case multipart-request-meter-case {
         container multipart-request-meter {
           leaf meter-id {
             type oft:meter-id;
           }
         }
       }
       case multipart-request-meter-config-case {
         container multipart-request-meter-config {
           leaf meter-id {
             type oft:meter-id;
           }
         }
       }
       case multipart-request-meter-features-case {
         container multipart-request-meter-features {
           leaf empty {
             type empty;
           }
         }
       }
       case multipart-request-table-features-case {
         container multipart-request-table-features {
           list table-features {
             leaf table-id {
               type uint8;
             }
             leaf name {
               type string;
             }
             leaf metadata-match {
               type uint64;
             }
             leaf metadata-write {
               type uint64;
             }
             leaf config {
               type oft:table-config;
             }
             leaf max-entries {
               type uint32;
             }
             uses table-features-properties-grouping;
           }
         }
       }
       case multipart-request-port-desc-case {
         container multipart-request-port-desc {
           leaf empty {
             type empty;
           }
         }
       }
       case multipart-request-experimenter-case {
         container multipart-request-experimenter {
           uses experimenter-core;
         }
       }
     }
   }
   grouping multipart-reply {
     uses ofHeader;
     leaf type {
       type oft:multipart-type;
     }
     leaf flags {
       type oft:multipart-request-flags;
     }
     choice multipart-reply-body {
       case multipart-reply-desc-case {
         container multipart-reply-desc {
           leaf mfr_desc {
             type string;
           }
           leaf hw_desc {
             type string;
           }
           leaf sw_desc {
             type string;
           }
           leaf serial_num {
             type string;
           }
           leaf dp_desc {
             type string;
           }
         }
       }
       case multipart-reply-flow-case {
         container multipart-reply-flow {
           list flow-stats {
             leaf table-id {
               type uint8;
             }
             leaf duration-sec {
               type uint32;
             }
             leaf duration-nsec {
               type uint32;
             }
             leaf priority {
               type uint16;
             }
             leaf idle-timeout {
               type uint16;
             }
             leaf hard-timeout {
               type uint16;
             }
             leaf flags {
               type oft:flow-mod-flags;
             }
             leaf cookie {
               type uint64;
             }
             leaf packet-count {
               type uint64;
             }
             leaf byte-count {
               type uint64;
             }
             uses oxm:match-grouping;
             uses ofinstruction:instructions-grouping;
             uses oxm:match-v10-grouping;
             uses ofaction:actions-grouping;
           }
         }
       }
       case multipart-reply-aggregate-case {
         container multipart-reply-aggregate {
           leaf packet-count {
             type uint64;
           }
           leaf byte-count {
             type uint64;
           }
           leaf flow-count {
             type uint32;
           }
         }
       }
       case multipart-reply-table-case {
         container multipart-reply-table {
           list table-stats {
             leaf table-id {
               type uint8;
             }
             leaf active-count {
               type uint32;
             }
             leaf lookup-count {
               type uint64;
             }
             leaf matched-count {
               type uint64;
             }
             leaf name {
               type string;
             }
             leaf wildcards {
               type oft:flow-wildcards-v10;
             }
             leaf nw-src-mask {
               type uint8;
             }
             leaf nw-dst-mask {
               type uint8;
             }
             leaf max-entries {
               type uint32;
             }
           }
         }
       }
       case multipart-reply-port-stats-case {
         container multipart-reply-port-stats {
           list port-stats {
             leaf port-no {
               type uint32;
             }
             leaf rx-packets {
               type uint64;
             }
             leaf tx-packets {
               type uint64;
             }
             leaf rx-bytes {
               type uint64;
             }
             leaf tx-bytes {
               type uint64;
             }
             leaf rx-dropped {
               type uint64;
             }
             leaf tx-dropped {
               type uint64;
             }
             leaf rx-errors {
               type uint64;
             }
             leaf tx-errors {
               type uint64;
             }
             leaf rx-frame-err {
               type uint64;
             }
             leaf rx-over-err {
               type uint64;
             }
             leaf rx-crc-err {
               type uint64;
             }
             leaf collisions {
               type uint64;
             }
             leaf duration-sec {
               type uint32;
             }
             leaf duration-nsec {
               type uint32;
             }
           }
         }
       }
       case multipart-reply-queue-case {
         container multipart-reply-queue {
           list queue-stats {
             leaf port-no {
               type uint32;
             }
             leaf queue-id {
               type uint32;
             }
             leaf tx-bytes {
               type uint64;
             }
             leaf tx-packets {
               type uint64;
             }
             leaf tx-errors {
               type uint64;
             }
             leaf duration-sec {
               type uint32;
             }
             leaf duration-nsec {
               type uint32;
             }
           }
         }
       }
       case multipart-reply-group-case {
         container multipart-reply-group {
           list group-stats {
             leaf group-id {
               type oft:group-id;
             }
             leaf ref-count {
               type uint32;
             }
             leaf packet-count {
               type uint64;
             }
             leaf byte-count {
               type uint64;
             }
             leaf duration-sec {
               type uint32;
             }
             leaf duration-nsec {
               type uint32;
             }
             list bucket-stats {
               leaf packet-count {
                 type uint64;
               }
               leaf byte-count {
                 type uint64;
               }
             }
           }
         }
       }
       case multipart-reply-group-desc-case {
         container multipart-reply-group-desc {
           list group-desc {
             leaf type {
               type oft:group-type;
             }
             leaf group-id {
               type oft:group-id;
             }
             uses buckets-grouping;
           }
         }
       }
       case multipart-reply-group-features-case {
         container multipart-reply-group-features {
           leaf types {
             type oft:group-types;
           }
           leaf capabilities {
             type oft:group-capabilities;
           }
           leaf-list max_groups {
             type uint32;
           }
           leaf-list actions-bitmap {
             type oft:action-type;
           }
         }
       }
       case multipart-reply-meter-case {
         container multipart-reply-meter {
           list meter-stats {
             leaf meter-id {
               type oft:meter-id;
             }
             leaf flow-count {
               type uint32;
             }
             leaf packet-in-count {
               type uint64;
             }
             leaf byte-in-count {
               type uint64;
             }
             leaf duration-sec {
               type uint32;
             }
             leaf duration-nsec {
               type uint32;
             }
             list meter-band-stats {
               leaf packet-band-count {
                 type uint64;
               }
               leaf byte-band-count {
                 type uint64;
               }
             }
           }
         }
       }
       case multipart-reply-meter-config-case {
         container multipart-reply-meter-config {
           list meter-config {
             leaf flags {
               type oft:meter-flags;
             }
             leaf meter-id {
               type oft:meter-id;
             }
             list bands {
               uses meter-band-header;
             }
           }
         }
       }
       case multipart-reply-meter-features-case {
         container multipart-reply-meter-features {
           leaf max-meter {
             type uint32;
           }
           leaf band-types {
             type oft:meter-band-type-bitmap;
           }
           leaf capabilities {
             type oft:meter-flags;
           }
           leaf max-bands {
             type uint8;
           }
           leaf max-color {
             type uint8;
           }
         }
       }
       case multipart-reply-table-features-case {
         container multipart-reply-table-features {
           list table-features {
             leaf table-id {
               type uint8;
             }
             leaf name {
               type string;
             }
             leaf metadata-match {
               type binary;
             }
             leaf metadata-write {
               type binary;
             }
             leaf config {
               type oft:table-config;
             }
             leaf max-entries {
               type uint32;
             }
             uses table-features-properties-grouping;
           }
         }
       }
       case multipart-reply-port-desc-case {
         container multipart-reply-port-desc {
           list ports {
             uses port-grouping;
           }
         }
       }
       case multipart-reply-experimenter-case {
         container multipart-reply-experimenter {
           uses experimenter-core;
         }
       }
     }
   }
   grouping barrier-request {
     uses ofHeader;
   }
   grouping barrier-reply {
     uses ofHeader;
   }
   grouping queue-get-config-request {
     uses ofHeader;
     leaf port {
       type oft:port-number;
     }
   }
   grouping queue-get-config-reply {
     uses ofHeader;
     leaf port {
       type oft:port-number;
     }
     list queues {
       uses packet-queue;
     }
   }
   grouping packet-queue {
     leaf queue-id {
       type oft:queue-id;
     }
     leaf port {
       type oft:port-number;
     }
     uses queue-property-header;
   }
   container queue-prop-container {
     uses queue-property-header;
   }
   grouping queue-property-header {
     list queue-property {
       config false;
       leaf property {
         type oft:queue-properties;
       }
     }
   }
   grouping role-request {
     uses ofHeader;
     leaf role {
       type oft:controller-role;
     }
     leaf generation-id {
       type uint64;
     }
   }
   grouping role-reply {
     uses ofHeader;
     leaf role {
       type oft:controller-role;
     }
     leaf generation-id {
       type uint64;
     }
   }
   grouping get-async-request {
     uses ofHeader;
   }
   grouping get-async-reply {
     uses ofHeader;
     uses async-body-grouping;
   }
   grouping set-async {
     uses ofHeader;
     uses async-body-grouping;
   }
   grouping async-body-grouping {
     list packet-in-mask {
       leaf-list mask {
         type oft:packet-in-reason;
       }
     }
     list port-status-mask {
       leaf-list mask {
         type oft:port-reason;
       }
     }
     list flow-removed-mask {
       leaf-list mask {
         type oft:flow-removed-reason;
       }
     }
   }
   grouping meter-mod {
     uses ofHeader;
     leaf command {
       type oft:meter-mod-command;
     }
     leaf flags {
       type oft:meter-flags;
     }
     leaf meter-id {
       type oft:meter-id;
     }
     list bands {
       uses meter-band-header;
     }
   }
   container meter-band-container {
     uses meter-band-header;
   }
   grouping meter-band-header {
     choice meter-band {
       case meter-band-drop-case {
         container meter-band-drop {
           uses meter-band-commons;
         }
       }
       case meter-band-dscp-remark-case {
         container meter-band-dscp-remark {
           uses meter-band-commons;
           leaf prec-level {
             type uint8;
           }
         }
       }
       case meter-band-experimenter-case {
         container meter-band-experimenter {
           uses meter-band-commons;
         }
       }
     }
   }
   grouping meter-band-commons {
     leaf type {
       type oft:meter-band-type;
     }
     leaf rate {
       type uint32;
     }
     leaf burst-size {
       type uint32;
     }
   }
   notification hello-message {
     uses hello;
   }
   notification error-message {
     uses error;
   }
   notification echo-request-message {
     uses echo-request;
   }
   notification experimenter-message {
     uses experimenter-of-message;
   }
   rpc echo {
     input input {
       uses echo-request;
     }
     output output {
       uses echo-reply;
     }
   }
   rpc echo-reply {
     input input {
       uses echo-reply;
     }
   }
   rpc hello {
     input input {
       uses hello;
     }
   }
   rpc experimenter {
     input input {
       uses experimenter-of-message;
     }
   }
   rpc get-features {
     input input {
       uses features-request;
     }
     output output {
       uses features-reply;
     }
   }
   rpc get-config {
     input input {
       uses get-config-request;
     }
     output output {
       uses get-config-reply;
     }
   }
   rpc set-config {
     input input {
       uses set-config;
     }
   }
   notification packet-in-message {
     uses packet-in;
   }
   notification flow-removed-message {
     uses flow-removed;
   }
   notification port-status-message {
     uses port-status;
   }
   rpc packet-out {
     input input {
       uses packet-out;
     }
   }
   rpc flow-mod {
     input input {
       uses flow-mod;
     }
   }
   rpc group-mod {
     input input {
       uses group-mod;
     }
   }
   rpc port-mod {
     input input {
       uses port-mod;
     }
   }
   rpc table-mod {
     input input {
       uses table-mod;
     }
   }
   rpc multipart-request {
     input input {
       uses multipart-request;
     }
   }
   notification multipart-reply-message {
     uses multipart-reply;
   }
   rpc barrier {
     input input {
       uses barrier-request;
     }
     output output {
       uses barrier-reply;
     }
   }
   rpc get-queue-config {
     input input {
       uses queue-get-config-request;
     }
     output output {
       uses queue-get-config-reply;
     }
   }
   rpc role-request {
     input input {
       uses role-request;
     }
     output output {
       uses role-reply;
     }
   }
   rpc get-async {
     input input {
       uses get-async-request;
     }
     output output {
       uses get-async-reply;
     }
   }
   rpc set-async {
     input input {
       uses set-async;
     }
   }
   rpc meter-mod {
     input input {
       uses meter-mod;
     }
   }
 }

Method Summary

All Methods Instance Methods Abstract Methods
Modifier and Type	Method	Description
`MeterBandContainer`	`getMeterBandContainer()`	Return meterBandContainer, or `null` if it is not present.
`QueuePropContainer`	`getQueuePropContainer()`	Return queuePropContainer, or `null` if it is not present.
`TableFeaturesPropertiesContainer`	`getTableFeaturesPropertiesContainer()`	Return tableFeaturesPropertiesContainer, or `null` if it is not present.

- Method Detail
  - getTableFeaturesPropertiesContainer
```
TableFeaturesPropertiesContainer getTableFeaturesPropertiesContainer()
```
    Return tableFeaturesPropertiesContainer, or null if it is not present.
    
    Returns:
    
    org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.TableFeaturesPropertiesContainer tableFeaturesPropertiesContainer, or null if it is not present.
  - getQueuePropContainer
```
QueuePropContainer getQueuePropContainer()
```
    Return queuePropContainer, or null if it is not present.
    
    Returns:
    
    org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.QueuePropContainer queuePropContainer, or null if it is not present.
  - getMeterBandContainer
```
MeterBandContainer getMeterBandContainer()
```
    Return meterBandContainer, or null if it is not present.
    
    Returns:
    
    org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.MeterBandContainer meterBandContainer, or null if it is not present.

Interface OpenflowProtocolData

Method Summary

Method Detail

getTableFeaturesPropertiesContainer

getQueuePropContainer

getMeterBandContainer