binapi/tunnel_types/tunnel_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:              21.06-release
   5 // source: /usr/share/vpp/api/core/tunnel_types.api.json
   6
   7 // Package tunnel_types contains generated bindings for API file tunnel_types.api.
   8 //
   9 // Contents:
  10 //   3 enums
  11 //   1 struct
  12 //
  13 package tunnel_types
  14
  15 import (
  16         "strconv"
  17
  18         api "git.fd.io/govpp.git/api"
  19         interface_types "git.fd.io/govpp.git/binapi/interface_types"
  20         ip_types "git.fd.io/govpp.git/binapi/ip_types"
  21 )
  22
  23 // This is a compile-time assertion to ensure that this generated file
  24 // is compatible with the GoVPP api package it is being compiled against.
  25 // A compilation error at this line likely means your copy of the
  26 // GoVPP api package needs to be updated.
  27 const _ = api.GoVppAPIPackageIsVersion2
  28
  29 // TunnelEncapDecapFlags defines enum 'tunnel_encap_decap_flags'.
  30 type TunnelEncapDecapFlags uint8
  31
  32 const (
  33         TUNNEL_API_ENCAP_DECAP_FLAG_NONE                  TunnelEncapDecapFlags = 0
  34         TUNNEL_API_ENCAP_DECAP_FLAG_ENCAP_COPY_DF         TunnelEncapDecapFlags = 1
  35         TUNNEL_API_ENCAP_DECAP_FLAG_ENCAP_SET_DF          TunnelEncapDecapFlags = 2
  36         TUNNEL_API_ENCAP_DECAP_FLAG_ENCAP_COPY_DSCP       TunnelEncapDecapFlags = 4
  37         TUNNEL_API_ENCAP_DECAP_FLAG_ENCAP_COPY_ECN        TunnelEncapDecapFlags = 8
  38         TUNNEL_API_ENCAP_DECAP_FLAG_DECAP_COPY_ECN        TunnelEncapDecapFlags = 16
  39         TUNNEL_API_ENCAP_DECAP_FLAG_ENCAP_INNER_HASH      TunnelEncapDecapFlags = 32
  40         TUNNEL_API_ENCAP_DECAP_FLAG_ENCAP_COPY_HOP_LIMIT  TunnelEncapDecapFlags = 64
  41         TUNNEL_API_ENCAP_DECAP_FLAG_ENCAP_COPY_FLOW_LABEL TunnelEncapDecapFlags = 128
  42 )
  43
  44 var (
  45         TunnelEncapDecapFlags_name = map[uint8]string{
  46                 0:   "TUNNEL_API_ENCAP_DECAP_FLAG_NONE",
  47                 1:   "TUNNEL_API_ENCAP_DECAP_FLAG_ENCAP_COPY_DF",
  48                 2:   "TUNNEL_API_ENCAP_DECAP_FLAG_ENCAP_SET_DF",
  49                 4:   "TUNNEL_API_ENCAP_DECAP_FLAG_ENCAP_COPY_DSCP",
  50                 8:   "TUNNEL_API_ENCAP_DECAP_FLAG_ENCAP_COPY_ECN",
  51                 16:  "TUNNEL_API_ENCAP_DECAP_FLAG_DECAP_COPY_ECN",
  52                 32:  "TUNNEL_API_ENCAP_DECAP_FLAG_ENCAP_INNER_HASH",
  53                 64:  "TUNNEL_API_ENCAP_DECAP_FLAG_ENCAP_COPY_HOP_LIMIT",
  54                 128: "TUNNEL_API_ENCAP_DECAP_FLAG_ENCAP_COPY_FLOW_LABEL",
  55         }
  56         TunnelEncapDecapFlags_value = map[string]uint8{
  57                 "TUNNEL_API_ENCAP_DECAP_FLAG_NONE":                  0,
  58                 "TUNNEL_API_ENCAP_DECAP_FLAG_ENCAP_COPY_DF":         1,
  59                 "TUNNEL_API_ENCAP_DECAP_FLAG_ENCAP_SET_DF":          2,
  60                 "TUNNEL_API_ENCAP_DECAP_FLAG_ENCAP_COPY_DSCP":       4,
  61                 "TUNNEL_API_ENCAP_DECAP_FLAG_ENCAP_COPY_ECN":        8,
  62                 "TUNNEL_API_ENCAP_DECAP_FLAG_DECAP_COPY_ECN":        16,
  63                 "TUNNEL_API_ENCAP_DECAP_FLAG_ENCAP_INNER_HASH":      32,
  64                 "TUNNEL_API_ENCAP_DECAP_FLAG_ENCAP_COPY_HOP_LIMIT":  64,
  65                 "TUNNEL_API_ENCAP_DECAP_FLAG_ENCAP_COPY_FLOW_LABEL": 128,
  66         }
  67 )
  68
  69 func (x TunnelEncapDecapFlags) String() string {
  70         s, ok := TunnelEncapDecapFlags_name[uint8(x)]
  71         if ok {
  72                 return s
  73         }
  74         str := func(n uint8) string {
  75                 s, ok := TunnelEncapDecapFlags_name[uint8(n)]
  76                 if ok {
  77                         return s
  78                 }
  79                 return "TunnelEncapDecapFlags(" + strconv.Itoa(int(n)) + ")"
  80         }
  81         for i := uint8(0); i <= 8; i++ {
  82                 val := uint8(x)
  83                 if val&(1<<i) != 0 {
  84                         if s != "" {
  85                                 s += "|"
  86                         }
  87                         s += str(1 << i)
  88                 }
  89         }
  90         if s == "" {
  91                 return str(uint8(x))
  92         }
  93         return s
  94 }
  95
  96 // TunnelMode defines enum 'tunnel_mode'.
  97 type TunnelMode uint8
  98
  99 const (
 100         TUNNEL_API_MODE_P2P TunnelMode = 0
 101         TUNNEL_API_MODE_MP  TunnelMode = 1
 102 )
 103
 104 var (
 105         TunnelMode_name = map[uint8]string{
 106                 0: "TUNNEL_API_MODE_P2P",
 107                 1: "TUNNEL_API_MODE_MP",
 108         }
 109         TunnelMode_value = map[string]uint8{
 110                 "TUNNEL_API_MODE_P2P": 0,
 111                 "TUNNEL_API_MODE_MP":  1,
 112         }
 113 )
 114
 115 func (x TunnelMode) String() string {
 116         s, ok := TunnelMode_name[uint8(x)]
 117         if ok {
 118                 return s
 119         }
 120         return "TunnelMode(" + strconv.Itoa(int(x)) + ")"
 121 }
 122
 123 // TunnelFlags defines enum 'tunnel_flags'.
 124 type TunnelFlags uint8
 125
 126 const (
 127         TUNNEL_API_FLAG_TRACK_MTU TunnelFlags = 1
 128 )
 129
 130 var (
 131         TunnelFlags_name = map[uint8]string{
 132                 1: "TUNNEL_API_FLAG_TRACK_MTU",
 133         }
 134         TunnelFlags_value = map[string]uint8{
 135                 "TUNNEL_API_FLAG_TRACK_MTU": 1,
 136         }
 137 )
 138
 139 func (x TunnelFlags) String() string {
 140         s, ok := TunnelFlags_name[uint8(x)]
 141         if ok {
 142                 return s
 143         }
 144         str := func(n uint8) string {
 145                 s, ok := TunnelFlags_name[uint8(n)]
 146                 if ok {
 147                         return s
 148                 }
 149                 return "TunnelFlags(" + strconv.Itoa(int(n)) + ")"
 150         }
 151         for i := uint8(0); i <= 8; i++ {
 152                 val := uint8(x)
 153                 if val&(1<<i) != 0 {
 154                         if s != "" {
 155                                 s += "|"
 156                         }
 157                         s += str(1 << i)
 158                 }
 159         }
 160         if s == "" {
 161                 return str(uint8(x))
 162         }
 163         return s
 164 }
 165
 166 // Tunnel defines type 'tunnel'.
 167 type Tunnel struct {
 168         Instance        uint32                         `binapi:"u32,name=instance" json:"instance,omitempty"`
 169         Src             ip_types.Address               `binapi:"address,name=src" json:"src,omitempty"`
 170         Dst             ip_types.Address               `binapi:"address,name=dst" json:"dst,omitempty"`
 171         SwIfIndex       interface_types.InterfaceIndex `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
 172         TableID         uint32                         `binapi:"u32,name=table_id" json:"table_id,omitempty"`
 173         EncapDecapFlags TunnelEncapDecapFlags          `binapi:"tunnel_encap_decap_flags,name=encap_decap_flags" json:"encap_decap_flags,omitempty"`
 174         Mode            TunnelMode                     `binapi:"tunnel_mode,name=mode" json:"mode,omitempty"`
 175         Flags           TunnelFlags                    `binapi:"tunnel_flags,name=flags" json:"flags,omitempty"`
 176         Dscp            ip_types.IPDscp                `binapi:"ip_dscp,name=dscp" json:"dscp,omitempty"`
 177         HopLimit        uint8                          `binapi:"u8,name=hop_limit" json:"hop_limit,omitempty"`
 178 }