internal/testbinapi/binapi2001/pg/pg.ba.go

   1 // Code generated by GoVPP's binapi-generator. DO NOT EDIT.
   2 // versions:
   3 //  binapi-generator: v0.5.0-dev
   4 //  VPP:              20.01
   5 // source: .vppapi/core/pg.api.json
   6
   7 // Package pg contains generated bindings for API file pg.api.
   8 //
   9 // Contents:
  10 //   6 messages
  11 //
  12 package pg
  13
  14 import (
  15         api "git.fd.io/govpp.git/api"
  16         codec "git.fd.io/govpp.git/codec"
  17 )
  18
  19 // This is a compile-time assertion to ensure that this generated file
  20 // is compatible with the GoVPP api package it is being compiled against.
  21 // A compilation error at this line likely means your copy of the
  22 // GoVPP api package needs to be updated.
  23 const _ = api.GoVppAPIPackageIsVersion2
  24
  25 const (
  26         APIFile    = "pg"
  27         APIVersion = "1.1.0"
  28         VersionCrc = 0x2583e07b
  29 )
  30
  31 // PgCapture defines message 'pg_capture'.
  32 type PgCapture struct {
  33         InterfaceID    uint32 `binapi:"u32,name=interface_id" json:"interface_id,omitempty"`
  34         IsEnabled      uint8  `binapi:"u8,name=is_enabled" json:"is_enabled,omitempty"`
  35         Count          uint32 `binapi:"u32,name=count" json:"count,omitempty"`
  36         PcapNameLength uint32 `binapi:"u32,name=pcap_name_length" json:"-"`
  37         PcapFileName   []byte `binapi:"u8[pcap_name_length],name=pcap_file_name" json:"pcap_file_name,omitempty"`
  38 }
  39
  40 func (m *PgCapture) Reset()               { *m = PgCapture{} }
  41 func (*PgCapture) GetMessageName() string { return "pg_capture" }
  42 func (*PgCapture) GetCrcString() string   { return "453da78d" }
  43 func (*PgCapture) GetMessageType() api.MessageType {
  44         return api.RequestMessage
  45 }
  46
  47 func (m *PgCapture) Size() (size int) {
  48         if m == nil {
  49                 return 0
  50         }
  51         size += 4                       // m.InterfaceID
  52         size += 1                       // m.IsEnabled
  53         size += 4                       // m.Count
  54         size += 4                       // m.PcapNameLength
  55         size += 1 * len(m.PcapFileName) // m.PcapFileName
  56         return size
  57 }
  58 func (m *PgCapture) Marshal(b []byte) ([]byte, error) {
  59         if b == nil {
  60                 b = make([]byte, m.Size())
  61         }
  62         buf := codec.NewBuffer(b)
  63         buf.EncodeUint32(m.InterfaceID)
  64         buf.EncodeUint8(m.IsEnabled)
  65         buf.EncodeUint32(m.Count)
  66         buf.EncodeUint32(uint32(len(m.PcapFileName)))
  67         buf.EncodeBytes(m.PcapFileName, 0)
  68         return buf.Bytes(), nil
  69 }
  70 func (m *PgCapture) Unmarshal(b []byte) error {
  71         buf := codec.NewBuffer(b)
  72         m.InterfaceID = buf.DecodeUint32()
  73         m.IsEnabled = buf.DecodeUint8()
  74         m.Count = buf.DecodeUint32()
  75         m.PcapNameLength = buf.DecodeUint32()
  76         m.PcapFileName = make([]byte, m.PcapNameLength)
  77         copy(m.PcapFileName, buf.DecodeBytes(len(m.PcapFileName)))
  78         return nil
  79 }
  80
  81 // PgCaptureReply defines message 'pg_capture_reply'.
  82 type PgCaptureReply struct {
  83         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
  84 }
  85
  86 func (m *PgCaptureReply) Reset()               { *m = PgCaptureReply{} }
  87 func (*PgCaptureReply) GetMessageName() string { return "pg_capture_reply" }
  88 func (*PgCaptureReply) GetCrcString() string   { return "e8d4e804" }
  89 func (*PgCaptureReply) GetMessageType() api.MessageType {
  90         return api.ReplyMessage
  91 }
  92
  93 func (m *PgCaptureReply) Size() (size int) {
  94         if m == nil {
  95                 return 0
  96         }
  97         size += 4 // m.Retval
  98         return size
  99 }
 100 func (m *PgCaptureReply) Marshal(b []byte) ([]byte, error) {
 101         if b == nil {
 102                 b = make([]byte, m.Size())
 103         }
 104         buf := codec.NewBuffer(b)
 105         buf.EncodeInt32(m.Retval)
 106         return buf.Bytes(), nil
 107 }
 108 func (m *PgCaptureReply) Unmarshal(b []byte) error {
 109         buf := codec.NewBuffer(b)
 110         m.Retval = buf.DecodeInt32()
 111         return nil
 112 }
 113
 114 // PgCreateInterface defines message 'pg_create_interface'.
 115 type PgCreateInterface struct {
 116         InterfaceID uint32 `binapi:"u32,name=interface_id" json:"interface_id,omitempty"`
 117         GsoEnabled  uint8  `binapi:"u8,name=gso_enabled" json:"gso_enabled,omitempty"`
 118         GsoSize     uint32 `binapi:"u32,name=gso_size" json:"gso_size,omitempty"`
 119 }
 120
 121 func (m *PgCreateInterface) Reset()               { *m = PgCreateInterface{} }
 122 func (*PgCreateInterface) GetMessageName() string { return "pg_create_interface" }
 123 func (*PgCreateInterface) GetCrcString() string   { return "b1ecff05" }
 124 func (*PgCreateInterface) GetMessageType() api.MessageType {
 125         return api.RequestMessage
 126 }
 127
 128 func (m *PgCreateInterface) Size() (size int) {
 129         if m == nil {
 130                 return 0
 131         }
 132         size += 4 // m.InterfaceID
 133         size += 1 // m.GsoEnabled
 134         size += 4 // m.GsoSize
 135         return size
 136 }
 137 func (m *PgCreateInterface) Marshal(b []byte) ([]byte, error) {
 138         if b == nil {
 139                 b = make([]byte, m.Size())
 140         }
 141         buf := codec.NewBuffer(b)
 142         buf.EncodeUint32(m.InterfaceID)
 143         buf.EncodeUint8(m.GsoEnabled)
 144         buf.EncodeUint32(m.GsoSize)
 145         return buf.Bytes(), nil
 146 }
 147 func (m *PgCreateInterface) Unmarshal(b []byte) error {
 148         buf := codec.NewBuffer(b)
 149         m.InterfaceID = buf.DecodeUint32()
 150         m.GsoEnabled = buf.DecodeUint8()
 151         m.GsoSize = buf.DecodeUint32()
 152         return nil
 153 }
 154
 155 // PgCreateInterfaceReply defines message 'pg_create_interface_reply'.
 156 type PgCreateInterfaceReply struct {
 157         Retval    int32  `binapi:"i32,name=retval" json:"retval,omitempty"`
 158         SwIfIndex uint32 `binapi:"u32,name=sw_if_index" json:"sw_if_index,omitempty"`
 159 }
 160
 161 func (m *PgCreateInterfaceReply) Reset()               { *m = PgCreateInterfaceReply{} }
 162 func (*PgCreateInterfaceReply) GetMessageName() string { return "pg_create_interface_reply" }
 163 func (*PgCreateInterfaceReply) GetCrcString() string   { return "fda5941f" }
 164 func (*PgCreateInterfaceReply) GetMessageType() api.MessageType {
 165         return api.ReplyMessage
 166 }
 167
 168 func (m *PgCreateInterfaceReply) Size() (size int) {
 169         if m == nil {
 170                 return 0
 171         }
 172         size += 4 // m.Retval
 173         size += 4 // m.SwIfIndex
 174         return size
 175 }
 176 func (m *PgCreateInterfaceReply) Marshal(b []byte) ([]byte, error) {
 177         if b == nil {
 178                 b = make([]byte, m.Size())
 179         }
 180         buf := codec.NewBuffer(b)
 181         buf.EncodeInt32(m.Retval)
 182         buf.EncodeUint32(m.SwIfIndex)
 183         return buf.Bytes(), nil
 184 }
 185 func (m *PgCreateInterfaceReply) Unmarshal(b []byte) error {
 186         buf := codec.NewBuffer(b)
 187         m.Retval = buf.DecodeInt32()
 188         m.SwIfIndex = buf.DecodeUint32()
 189         return nil
 190 }
 191
 192 // PgEnableDisable defines message 'pg_enable_disable'.
 193 type PgEnableDisable struct {
 194         IsEnabled        uint8  `binapi:"u8,name=is_enabled" json:"is_enabled,omitempty"`
 195         StreamNameLength uint32 `binapi:"u32,name=stream_name_length" json:"-"`
 196         StreamName       []byte `binapi:"u8[stream_name_length],name=stream_name" json:"stream_name,omitempty"`
 197 }
 198
 199 func (m *PgEnableDisable) Reset()               { *m = PgEnableDisable{} }
 200 func (*PgEnableDisable) GetMessageName() string { return "pg_enable_disable" }
 201 func (*PgEnableDisable) GetCrcString() string   { return "0cb71d10" }
 202 func (*PgEnableDisable) GetMessageType() api.MessageType {
 203         return api.RequestMessage
 204 }
 205
 206 func (m *PgEnableDisable) Size() (size int) {
 207         if m == nil {
 208                 return 0
 209         }
 210         size += 1                     // m.IsEnabled
 211         size += 4                     // m.StreamNameLength
 212         size += 1 * len(m.StreamName) // m.StreamName
 213         return size
 214 }
 215 func (m *PgEnableDisable) Marshal(b []byte) ([]byte, error) {
 216         if b == nil {
 217                 b = make([]byte, m.Size())
 218         }
 219         buf := codec.NewBuffer(b)
 220         buf.EncodeUint8(m.IsEnabled)
 221         buf.EncodeUint32(uint32(len(m.StreamName)))
 222         buf.EncodeBytes(m.StreamName, 0)
 223         return buf.Bytes(), nil
 224 }
 225 func (m *PgEnableDisable) Unmarshal(b []byte) error {
 226         buf := codec.NewBuffer(b)
 227         m.IsEnabled = buf.DecodeUint8()
 228         m.StreamNameLength = buf.DecodeUint32()
 229         m.StreamName = make([]byte, m.StreamNameLength)
 230         copy(m.StreamName, buf.DecodeBytes(len(m.StreamName)))
 231         return nil
 232 }
 233
 234 // PgEnableDisableReply defines message 'pg_enable_disable_reply'.
 235 type PgEnableDisableReply struct {
 236         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
 237 }
 238
 239 func (m *PgEnableDisableReply) Reset()               { *m = PgEnableDisableReply{} }
 240 func (*PgEnableDisableReply) GetMessageName() string { return "pg_enable_disable_reply" }
 241 func (*PgEnableDisableReply) GetCrcString() string   { return "e8d4e804" }
 242 func (*PgEnableDisableReply) GetMessageType() api.MessageType {
 243         return api.ReplyMessage
 244 }
 245
 246 func (m *PgEnableDisableReply) Size() (size int) {
 247         if m == nil {
 248                 return 0
 249         }
 250         size += 4 // m.Retval
 251         return size
 252 }
 253 func (m *PgEnableDisableReply) Marshal(b []byte) ([]byte, error) {
 254         if b == nil {
 255                 b = make([]byte, m.Size())
 256         }
 257         buf := codec.NewBuffer(b)
 258         buf.EncodeInt32(m.Retval)
 259         return buf.Bytes(), nil
 260 }
 261 func (m *PgEnableDisableReply) Unmarshal(b []byte) error {
 262         buf := codec.NewBuffer(b)
 263         m.Retval = buf.DecodeInt32()
 264         return nil
 265 }
 266
 267 func init() { file_pg_binapi_init() }
 268 func file_pg_binapi_init() {
 269         api.RegisterMessage((*PgCapture)(nil), "pg_capture_453da78d")
 270         api.RegisterMessage((*PgCaptureReply)(nil), "pg_capture_reply_e8d4e804")
 271         api.RegisterMessage((*PgCreateInterface)(nil), "pg_create_interface_b1ecff05")
 272         api.RegisterMessage((*PgCreateInterfaceReply)(nil), "pg_create_interface_reply_fda5941f")
 273         api.RegisterMessage((*PgEnableDisable)(nil), "pg_enable_disable_0cb71d10")
 274         api.RegisterMessage((*PgEnableDisableReply)(nil), "pg_enable_disable_reply_e8d4e804")
 275 }
 276
 277 // Messages returns list of all messages in this module.
 278 func AllMessages() []api.Message {
 279         return []api.Message{
 280                 (*PgCapture)(nil),
 281                 (*PgCaptureReply)(nil),
 282                 (*PgCreateInterface)(nil),
 283                 (*PgCreateInterfaceReply)(nil),
 284                 (*PgEnableDisable)(nil),
 285                 (*PgEnableDisableReply)(nil),
 286         }
 287 }