binapi/interface_types/interface_types.ba.go

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