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