examples/binapi/interface_types/interface_types.ba.go

   1 // Code generated by GoVPP's binapi-generator. DO NOT EDIT.
   2 // source: /usr/share/vpp/api/core/interface_types.api.json
   3
   4 /*
   5 Package interface_types is a generated VPP binary API for 'interface_types' module.
   6
   7 It consists of:
   8           6 enums
   9           1 alias
  10 */
  11 package interface_types
  12
  13 import (
  14         bytes "bytes"
  15         context "context"
  16         api "git.fd.io/govpp.git/api"
  17         struc "github.com/lunixbochs/struc"
  18         io "io"
  19         strconv "strconv"
  20 )
  21
  22 const (
  23         // ModuleName is the name of this module.
  24         ModuleName = "interface_types"
  25         // VersionCrc is the CRC of this module.
  26         VersionCrc = 0xc97be83d
  27 )
  28
  29 // IfStatusFlags represents VPP binary API enum 'if_status_flags'.
  30 type IfStatusFlags uint32
  31
  32 const (
  33         IF_STATUS_API_FLAG_ADMIN_UP IfStatusFlags = 1
  34         IF_STATUS_API_FLAG_LINK_UP  IfStatusFlags = 2
  35 )
  36
  37 var IfStatusFlags_name = map[uint32]string{
  38         1: "IF_STATUS_API_FLAG_ADMIN_UP",
  39         2: "IF_STATUS_API_FLAG_LINK_UP",
  40 }
  41
  42 var IfStatusFlags_value = map[string]uint32{
  43         "IF_STATUS_API_FLAG_ADMIN_UP": 1,
  44         "IF_STATUS_API_FLAG_LINK_UP":  2,
  45 }
  46
  47 func (x IfStatusFlags) String() string {
  48         s, ok := IfStatusFlags_name[uint32(x)]
  49         if ok {
  50                 return s
  51         }
  52         return strconv.Itoa(int(x))
  53 }
  54
  55 // IfType represents VPP binary API enum 'if_type'.
  56 type IfType uint32
  57
  58 const (
  59         IF_API_TYPE_HARDWARE IfType = 1
  60         IF_API_TYPE_SUB      IfType = 2
  61         IF_API_TYPE_P2P      IfType = 3
  62         IF_API_TYPE_PIPE     IfType = 4
  63 )
  64
  65 var IfType_name = map[uint32]string{
  66         1: "IF_API_TYPE_HARDWARE",
  67         2: "IF_API_TYPE_SUB",
  68         3: "IF_API_TYPE_P2P",
  69         4: "IF_API_TYPE_PIPE",
  70 }
  71
  72 var IfType_value = map[string]uint32{
  73         "IF_API_TYPE_HARDWARE": 1,
  74         "IF_API_TYPE_SUB":      2,
  75         "IF_API_TYPE_P2P":      3,
  76         "IF_API_TYPE_PIPE":     4,
  77 }
  78
  79 func (x IfType) String() string {
  80         s, ok := IfType_name[uint32(x)]
  81         if ok {
  82                 return s
  83         }
  84         return strconv.Itoa(int(x))
  85 }
  86
  87 // LinkDuplex represents VPP binary API enum 'link_duplex'.
  88 type LinkDuplex uint32
  89
  90 const (
  91         LINK_DUPLEX_API_UNKNOWN LinkDuplex = 0
  92         LINK_DUPLEX_API_HALF    LinkDuplex = 1
  93         LINK_DUPLEX_API_FULL    LinkDuplex = 2
  94 )
  95
  96 var LinkDuplex_name = map[uint32]string{
  97         0: "LINK_DUPLEX_API_UNKNOWN",
  98         1: "LINK_DUPLEX_API_HALF",
  99         2: "LINK_DUPLEX_API_FULL",
 100 }
 101
 102 var LinkDuplex_value = map[string]uint32{
 103         "LINK_DUPLEX_API_UNKNOWN": 0,
 104         "LINK_DUPLEX_API_HALF":    1,
 105         "LINK_DUPLEX_API_FULL":    2,
 106 }
 107
 108 func (x LinkDuplex) String() string {
 109         s, ok := LinkDuplex_name[uint32(x)]
 110         if ok {
 111                 return s
 112         }
 113         return strconv.Itoa(int(x))
 114 }
 115
 116 // MtuProto represents VPP binary API enum 'mtu_proto'.
 117 type MtuProto uint32
 118
 119 const (
 120         MTU_PROTO_API_L3   MtuProto = 1
 121         MTU_PROTO_API_IP4  MtuProto = 2
 122         MTU_PROTO_API_IP6  MtuProto = 3
 123         MTU_PROTO_API_MPLS MtuProto = 4
 124         MTU_PROTO_API_N    MtuProto = 5
 125 )
 126
 127 var MtuProto_name = map[uint32]string{
 128         1: "MTU_PROTO_API_L3",
 129         2: "MTU_PROTO_API_IP4",
 130         3: "MTU_PROTO_API_IP6",
 131         4: "MTU_PROTO_API_MPLS",
 132         5: "MTU_PROTO_API_N",
 133 }
 134
 135 var MtuProto_value = map[string]uint32{
 136         "MTU_PROTO_API_L3":   1,
 137         "MTU_PROTO_API_IP4":  2,
 138         "MTU_PROTO_API_IP6":  3,
 139         "MTU_PROTO_API_MPLS": 4,
 140         "MTU_PROTO_API_N":    5,
 141 }
 142
 143 func (x MtuProto) String() string {
 144         s, ok := MtuProto_name[uint32(x)]
 145         if ok {
 146                 return s
 147         }
 148         return strconv.Itoa(int(x))
 149 }
 150
 151 // RxMode represents VPP binary API enum 'rx_mode'.
 152 type RxMode uint32
 153
 154 const (
 155         RX_MODE_API_UNKNOWN   RxMode = 0
 156         RX_MODE_API_POLLING   RxMode = 1
 157         RX_MODE_API_INTERRUPT RxMode = 2
 158         RX_MODE_API_ADAPTIVE  RxMode = 3
 159         RX_MODE_API_DEFAULT   RxMode = 4
 160 )
 161
 162 var RxMode_name = map[uint32]string{
 163         0: "RX_MODE_API_UNKNOWN",
 164         1: "RX_MODE_API_POLLING",
 165         2: "RX_MODE_API_INTERRUPT",
 166         3: "RX_MODE_API_ADAPTIVE",
 167         4: "RX_MODE_API_DEFAULT",
 168 }
 169
 170 var RxMode_value = map[string]uint32{
 171         "RX_MODE_API_UNKNOWN":   0,
 172         "RX_MODE_API_POLLING":   1,
 173         "RX_MODE_API_INTERRUPT": 2,
 174         "RX_MODE_API_ADAPTIVE":  3,
 175         "RX_MODE_API_DEFAULT":   4,
 176 }
 177
 178 func (x RxMode) String() string {
 179         s, ok := RxMode_name[uint32(x)]
 180         if ok {
 181                 return s
 182         }
 183         return strconv.Itoa(int(x))
 184 }
 185
 186 // SubIfFlags represents VPP binary API enum 'sub_if_flags'.
 187 type SubIfFlags uint32
 188
 189 const (
 190         SUB_IF_API_FLAG_NO_TAGS           SubIfFlags = 1
 191         SUB_IF_API_FLAG_ONE_TAG           SubIfFlags = 2
 192         SUB_IF_API_FLAG_TWO_TAGS          SubIfFlags = 4
 193         SUB_IF_API_FLAG_DOT1AD            SubIfFlags = 8
 194         SUB_IF_API_FLAG_EXACT_MATCH       SubIfFlags = 16
 195         SUB_IF_API_FLAG_DEFAULT           SubIfFlags = 32
 196         SUB_IF_API_FLAG_OUTER_VLAN_ID_ANY SubIfFlags = 64
 197         SUB_IF_API_FLAG_INNER_VLAN_ID_ANY SubIfFlags = 128
 198         SUB_IF_API_FLAG_MASK_VNET         SubIfFlags = 254
 199         SUB_IF_API_FLAG_DOT1AH            SubIfFlags = 256
 200 )
 201
 202 var SubIfFlags_name = map[uint32]string{
 203         1:   "SUB_IF_API_FLAG_NO_TAGS",
 204         2:   "SUB_IF_API_FLAG_ONE_TAG",
 205         4:   "SUB_IF_API_FLAG_TWO_TAGS",
 206         8:   "SUB_IF_API_FLAG_DOT1AD",
 207         16:  "SUB_IF_API_FLAG_EXACT_MATCH",
 208         32:  "SUB_IF_API_FLAG_DEFAULT",
 209         64:  "SUB_IF_API_FLAG_OUTER_VLAN_ID_ANY",
 210         128: "SUB_IF_API_FLAG_INNER_VLAN_ID_ANY",
 211         254: "SUB_IF_API_FLAG_MASK_VNET",
 212         256: "SUB_IF_API_FLAG_DOT1AH",
 213 }
 214
 215 var SubIfFlags_value = map[string]uint32{
 216         "SUB_IF_API_FLAG_NO_TAGS":           1,
 217         "SUB_IF_API_FLAG_ONE_TAG":           2,
 218         "SUB_IF_API_FLAG_TWO_TAGS":          4,
 219         "SUB_IF_API_FLAG_DOT1AD":            8,
 220         "SUB_IF_API_FLAG_EXACT_MATCH":       16,
 221         "SUB_IF_API_FLAG_DEFAULT":           32,
 222         "SUB_IF_API_FLAG_OUTER_VLAN_ID_ANY": 64,
 223         "SUB_IF_API_FLAG_INNER_VLAN_ID_ANY": 128,
 224         "SUB_IF_API_FLAG_MASK_VNET":         254,
 225         "SUB_IF_API_FLAG_DOT1AH":            256,
 226 }
 227
 228 func (x SubIfFlags) String() string {
 229         s, ok := SubIfFlags_name[uint32(x)]
 230         if ok {
 231                 return s
 232         }
 233         return strconv.Itoa(int(x))
 234 }
 235
 236 // InterfaceIndex represents VPP binary API alias 'interface_index'.
 237 type InterfaceIndex uint32
 238
 239 // This is a compile-time assertion to ensure that this generated file
 240 // is compatible with the GoVPP api package it is being compiled against.
 241 // A compilation error at this line likely means your copy of the
 242 // GoVPP api package needs to be updated.
 243 const _ = api.GoVppAPIPackageIsVersion1 // please upgrade the GoVPP api package
 244
 245 // Reference imports to suppress errors if they are not otherwise used.
 246 var _ = api.RegisterMessage
 247 var _ = bytes.NewBuffer
 248 var _ = context.Background
 249 var _ = io.Copy
 250 var _ = strconv.Itoa
 251 var _ = struc.Pack