binapi/ipfix_export/ipfix_export.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/ipfix_export.api.json
   6
   7 // Package ipfix_export contains generated bindings for API file ipfix_export.api.
   8 //
   9 // Contents:
  10 //  14 messages
  11 //
  12 package ipfix_export
  13
  14 import (
  15         api "git.fd.io/govpp.git/api"
  16         ip_types "git.fd.io/govpp.git/binapi/ip_types"
  17         codec "git.fd.io/govpp.git/codec"
  18 )
  19
  20 // This is a compile-time assertion to ensure that this generated file
  21 // is compatible with the GoVPP api package it is being compiled against.
  22 // A compilation error at this line likely means your copy of the
  23 // GoVPP api package needs to be updated.
  24 const _ = api.GoVppAPIPackageIsVersion2
  25
  26 const (
  27         APIFile    = "ipfix_export"
  28         APIVersion = "2.0.1"
  29         VersionCrc = 0xb7e9cad2
  30 )
  31
  32 // IpfixClassifyStreamDetails defines message 'ipfix_classify_stream_details'.
  33 type IpfixClassifyStreamDetails struct {
  34         DomainID uint32 `binapi:"u32,name=domain_id" json:"domain_id,omitempty"`
  35         SrcPort  uint16 `binapi:"u16,name=src_port" json:"src_port,omitempty"`
  36 }
  37
  38 func (m *IpfixClassifyStreamDetails) Reset()               { *m = IpfixClassifyStreamDetails{} }
  39 func (*IpfixClassifyStreamDetails) GetMessageName() string { return "ipfix_classify_stream_details" }
  40 func (*IpfixClassifyStreamDetails) GetCrcString() string   { return "2903539d" }
  41 func (*IpfixClassifyStreamDetails) GetMessageType() api.MessageType {
  42         return api.ReplyMessage
  43 }
  44
  45 func (m *IpfixClassifyStreamDetails) Size() int {
  46         if m == nil {
  47                 return 0
  48         }
  49         var size int
  50         size += 4 // m.DomainID
  51         size += 2 // m.SrcPort
  52         return size
  53 }
  54 func (m *IpfixClassifyStreamDetails) Marshal(b []byte) ([]byte, error) {
  55         var buf *codec.Buffer
  56         if b == nil {
  57                 buf = codec.NewBuffer(make([]byte, m.Size()))
  58         } else {
  59                 buf = codec.NewBuffer(b)
  60         }
  61         buf.EncodeUint32(uint32(m.DomainID))
  62         buf.EncodeUint16(uint16(m.SrcPort))
  63         return buf.Bytes(), nil
  64 }
  65 func (m *IpfixClassifyStreamDetails) Unmarshal(b []byte) error {
  66         buf := codec.NewBuffer(b)
  67         m.DomainID = buf.DecodeUint32()
  68         m.SrcPort = buf.DecodeUint16()
  69         return nil
  70 }
  71
  72 // IpfixClassifyStreamDump defines message 'ipfix_classify_stream_dump'.
  73 type IpfixClassifyStreamDump struct{}
  74
  75 func (m *IpfixClassifyStreamDump) Reset()               { *m = IpfixClassifyStreamDump{} }
  76 func (*IpfixClassifyStreamDump) GetMessageName() string { return "ipfix_classify_stream_dump" }
  77 func (*IpfixClassifyStreamDump) GetCrcString() string   { return "51077d14" }
  78 func (*IpfixClassifyStreamDump) GetMessageType() api.MessageType {
  79         return api.RequestMessage
  80 }
  81
  82 func (m *IpfixClassifyStreamDump) Size() int {
  83         if m == nil {
  84                 return 0
  85         }
  86         var size int
  87         return size
  88 }
  89 func (m *IpfixClassifyStreamDump) Marshal(b []byte) ([]byte, error) {
  90         var buf *codec.Buffer
  91         if b == nil {
  92                 buf = codec.NewBuffer(make([]byte, m.Size()))
  93         } else {
  94                 buf = codec.NewBuffer(b)
  95         }
  96         return buf.Bytes(), nil
  97 }
  98 func (m *IpfixClassifyStreamDump) Unmarshal(b []byte) error {
  99         return nil
 100 }
 101
 102 // IpfixClassifyTableAddDel defines message 'ipfix_classify_table_add_del'.
 103 type IpfixClassifyTableAddDel struct {
 104         TableID           uint32                 `binapi:"u32,name=table_id" json:"table_id,omitempty"`
 105         IPVersion         ip_types.AddressFamily `binapi:"address_family,name=ip_version" json:"ip_version,omitempty"`
 106         TransportProtocol ip_types.IPProto       `binapi:"ip_proto,name=transport_protocol" json:"transport_protocol,omitempty"`
 107         IsAdd             bool                   `binapi:"bool,name=is_add" json:"is_add,omitempty"`
 108 }
 109
 110 func (m *IpfixClassifyTableAddDel) Reset()               { *m = IpfixClassifyTableAddDel{} }
 111 func (*IpfixClassifyTableAddDel) GetMessageName() string { return "ipfix_classify_table_add_del" }
 112 func (*IpfixClassifyTableAddDel) GetCrcString() string   { return "3e449bb9" }
 113 func (*IpfixClassifyTableAddDel) GetMessageType() api.MessageType {
 114         return api.RequestMessage
 115 }
 116
 117 func (m *IpfixClassifyTableAddDel) Size() int {
 118         if m == nil {
 119                 return 0
 120         }
 121         var size int
 122         size += 4 // m.TableID
 123         size += 1 // m.IPVersion
 124         size += 1 // m.TransportProtocol
 125         size += 1 // m.IsAdd
 126         return size
 127 }
 128 func (m *IpfixClassifyTableAddDel) Marshal(b []byte) ([]byte, error) {
 129         var buf *codec.Buffer
 130         if b == nil {
 131                 buf = codec.NewBuffer(make([]byte, m.Size()))
 132         } else {
 133                 buf = codec.NewBuffer(b)
 134         }
 135         buf.EncodeUint32(uint32(m.TableID))
 136         buf.EncodeUint8(uint8(m.IPVersion))
 137         buf.EncodeUint8(uint8(m.TransportProtocol))
 138         buf.EncodeBool(m.IsAdd)
 139         return buf.Bytes(), nil
 140 }
 141 func (m *IpfixClassifyTableAddDel) Unmarshal(b []byte) error {
 142         buf := codec.NewBuffer(b)
 143         m.TableID = buf.DecodeUint32()
 144         m.IPVersion = ip_types.AddressFamily(buf.DecodeUint8())
 145         m.TransportProtocol = ip_types.IPProto(buf.DecodeUint8())
 146         m.IsAdd = buf.DecodeBool()
 147         return nil
 148 }
 149
 150 // IpfixClassifyTableAddDelReply defines message 'ipfix_classify_table_add_del_reply'.
 151 type IpfixClassifyTableAddDelReply struct {
 152         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
 153 }
 154
 155 func (m *IpfixClassifyTableAddDelReply) Reset() { *m = IpfixClassifyTableAddDelReply{} }
 156 func (*IpfixClassifyTableAddDelReply) GetMessageName() string {
 157         return "ipfix_classify_table_add_del_reply"
 158 }
 159 func (*IpfixClassifyTableAddDelReply) GetCrcString() string { return "e8d4e804" }
 160 func (*IpfixClassifyTableAddDelReply) GetMessageType() api.MessageType {
 161         return api.ReplyMessage
 162 }
 163
 164 func (m *IpfixClassifyTableAddDelReply) Size() int {
 165         if m == nil {
 166                 return 0
 167         }
 168         var size int
 169         size += 4 // m.Retval
 170         return size
 171 }
 172 func (m *IpfixClassifyTableAddDelReply) Marshal(b []byte) ([]byte, error) {
 173         var buf *codec.Buffer
 174         if b == nil {
 175                 buf = codec.NewBuffer(make([]byte, m.Size()))
 176         } else {
 177                 buf = codec.NewBuffer(b)
 178         }
 179         buf.EncodeUint32(uint32(m.Retval))
 180         return buf.Bytes(), nil
 181 }
 182 func (m *IpfixClassifyTableAddDelReply) Unmarshal(b []byte) error {
 183         buf := codec.NewBuffer(b)
 184         m.Retval = int32(buf.DecodeUint32())
 185         return nil
 186 }
 187
 188 // IpfixClassifyTableDetails defines message 'ipfix_classify_table_details'.
 189 type IpfixClassifyTableDetails struct {
 190         TableID           uint32                 `binapi:"u32,name=table_id" json:"table_id,omitempty"`
 191         IPVersion         ip_types.AddressFamily `binapi:"address_family,name=ip_version" json:"ip_version,omitempty"`
 192         TransportProtocol ip_types.IPProto       `binapi:"ip_proto,name=transport_protocol" json:"transport_protocol,omitempty"`
 193 }
 194
 195 func (m *IpfixClassifyTableDetails) Reset()               { *m = IpfixClassifyTableDetails{} }
 196 func (*IpfixClassifyTableDetails) GetMessageName() string { return "ipfix_classify_table_details" }
 197 func (*IpfixClassifyTableDetails) GetCrcString() string   { return "1af8c28c" }
 198 func (*IpfixClassifyTableDetails) GetMessageType() api.MessageType {
 199         return api.ReplyMessage
 200 }
 201
 202 func (m *IpfixClassifyTableDetails) Size() int {
 203         if m == nil {
 204                 return 0
 205         }
 206         var size int
 207         size += 4 // m.TableID
 208         size += 1 // m.IPVersion
 209         size += 1 // m.TransportProtocol
 210         return size
 211 }
 212 func (m *IpfixClassifyTableDetails) Marshal(b []byte) ([]byte, error) {
 213         var buf *codec.Buffer
 214         if b == nil {
 215                 buf = codec.NewBuffer(make([]byte, m.Size()))
 216         } else {
 217                 buf = codec.NewBuffer(b)
 218         }
 219         buf.EncodeUint32(uint32(m.TableID))
 220         buf.EncodeUint8(uint8(m.IPVersion))
 221         buf.EncodeUint8(uint8(m.TransportProtocol))
 222         return buf.Bytes(), nil
 223 }
 224 func (m *IpfixClassifyTableDetails) Unmarshal(b []byte) error {
 225         buf := codec.NewBuffer(b)
 226         m.TableID = buf.DecodeUint32()
 227         m.IPVersion = ip_types.AddressFamily(buf.DecodeUint8())
 228         m.TransportProtocol = ip_types.IPProto(buf.DecodeUint8())
 229         return nil
 230 }
 231
 232 // IpfixClassifyTableDump defines message 'ipfix_classify_table_dump'.
 233 type IpfixClassifyTableDump struct{}
 234
 235 func (m *IpfixClassifyTableDump) Reset()               { *m = IpfixClassifyTableDump{} }
 236 func (*IpfixClassifyTableDump) GetMessageName() string { return "ipfix_classify_table_dump" }
 237 func (*IpfixClassifyTableDump) GetCrcString() string   { return "51077d14" }
 238 func (*IpfixClassifyTableDump) GetMessageType() api.MessageType {
 239         return api.RequestMessage
 240 }
 241
 242 func (m *IpfixClassifyTableDump) Size() int {
 243         if m == nil {
 244                 return 0
 245         }
 246         var size int
 247         return size
 248 }
 249 func (m *IpfixClassifyTableDump) Marshal(b []byte) ([]byte, error) {
 250         var buf *codec.Buffer
 251         if b == nil {
 252                 buf = codec.NewBuffer(make([]byte, m.Size()))
 253         } else {
 254                 buf = codec.NewBuffer(b)
 255         }
 256         return buf.Bytes(), nil
 257 }
 258 func (m *IpfixClassifyTableDump) Unmarshal(b []byte) error {
 259         return nil
 260 }
 261
 262 // IpfixExporterDetails defines message 'ipfix_exporter_details'.
 263 type IpfixExporterDetails struct {
 264         CollectorAddress ip_types.Address `binapi:"address,name=collector_address" json:"collector_address,omitempty"`
 265         CollectorPort    uint16           `binapi:"u16,name=collector_port" json:"collector_port,omitempty"`
 266         SrcAddress       ip_types.Address `binapi:"address,name=src_address" json:"src_address,omitempty"`
 267         VrfID            uint32           `binapi:"u32,name=vrf_id" json:"vrf_id,omitempty"`
 268         PathMtu          uint32           `binapi:"u32,name=path_mtu" json:"path_mtu,omitempty"`
 269         TemplateInterval uint32           `binapi:"u32,name=template_interval" json:"template_interval,omitempty"`
 270         UDPChecksum      bool             `binapi:"bool,name=udp_checksum" json:"udp_checksum,omitempty"`
 271 }
 272
 273 func (m *IpfixExporterDetails) Reset()               { *m = IpfixExporterDetails{} }
 274 func (*IpfixExporterDetails) GetMessageName() string { return "ipfix_exporter_details" }
 275 func (*IpfixExporterDetails) GetCrcString() string   { return "11e07413" }
 276 func (*IpfixExporterDetails) GetMessageType() api.MessageType {
 277         return api.ReplyMessage
 278 }
 279
 280 func (m *IpfixExporterDetails) Size() int {
 281         if m == nil {
 282                 return 0
 283         }
 284         var size int
 285         size += 1      // m.CollectorAddress.Af
 286         size += 1 * 16 // m.CollectorAddress.Un
 287         size += 2      // m.CollectorPort
 288         size += 1      // m.SrcAddress.Af
 289         size += 1 * 16 // m.SrcAddress.Un
 290         size += 4      // m.VrfID
 291         size += 4      // m.PathMtu
 292         size += 4      // m.TemplateInterval
 293         size += 1      // m.UDPChecksum
 294         return size
 295 }
 296 func (m *IpfixExporterDetails) Marshal(b []byte) ([]byte, error) {
 297         var buf *codec.Buffer
 298         if b == nil {
 299                 buf = codec.NewBuffer(make([]byte, m.Size()))
 300         } else {
 301                 buf = codec.NewBuffer(b)
 302         }
 303         buf.EncodeUint8(uint8(m.CollectorAddress.Af))
 304         buf.EncodeBytes(m.CollectorAddress.Un.XXX_UnionData[:], 0)
 305         buf.EncodeUint16(uint16(m.CollectorPort))
 306         buf.EncodeUint8(uint8(m.SrcAddress.Af))
 307         buf.EncodeBytes(m.SrcAddress.Un.XXX_UnionData[:], 0)
 308         buf.EncodeUint32(uint32(m.VrfID))
 309         buf.EncodeUint32(uint32(m.PathMtu))
 310         buf.EncodeUint32(uint32(m.TemplateInterval))
 311         buf.EncodeBool(m.UDPChecksum)
 312         return buf.Bytes(), nil
 313 }
 314 func (m *IpfixExporterDetails) Unmarshal(b []byte) error {
 315         buf := codec.NewBuffer(b)
 316         m.CollectorAddress.Af = ip_types.AddressFamily(buf.DecodeUint8())
 317         copy(m.CollectorAddress.Un.XXX_UnionData[:], buf.DecodeBytes(16))
 318         m.CollectorPort = buf.DecodeUint16()
 319         m.SrcAddress.Af = ip_types.AddressFamily(buf.DecodeUint8())
 320         copy(m.SrcAddress.Un.XXX_UnionData[:], buf.DecodeBytes(16))
 321         m.VrfID = buf.DecodeUint32()
 322         m.PathMtu = buf.DecodeUint32()
 323         m.TemplateInterval = buf.DecodeUint32()
 324         m.UDPChecksum = buf.DecodeBool()
 325         return nil
 326 }
 327
 328 // IpfixExporterDump defines message 'ipfix_exporter_dump'.
 329 type IpfixExporterDump struct{}
 330
 331 func (m *IpfixExporterDump) Reset()               { *m = IpfixExporterDump{} }
 332 func (*IpfixExporterDump) GetMessageName() string { return "ipfix_exporter_dump" }
 333 func (*IpfixExporterDump) GetCrcString() string   { return "51077d14" }
 334 func (*IpfixExporterDump) GetMessageType() api.MessageType {
 335         return api.RequestMessage
 336 }
 337
 338 func (m *IpfixExporterDump) Size() int {
 339         if m == nil {
 340                 return 0
 341         }
 342         var size int
 343         return size
 344 }
 345 func (m *IpfixExporterDump) Marshal(b []byte) ([]byte, error) {
 346         var buf *codec.Buffer
 347         if b == nil {
 348                 buf = codec.NewBuffer(make([]byte, m.Size()))
 349         } else {
 350                 buf = codec.NewBuffer(b)
 351         }
 352         return buf.Bytes(), nil
 353 }
 354 func (m *IpfixExporterDump) Unmarshal(b []byte) error {
 355         return nil
 356 }
 357
 358 // IpfixFlush defines message 'ipfix_flush'.
 359 type IpfixFlush struct{}
 360
 361 func (m *IpfixFlush) Reset()               { *m = IpfixFlush{} }
 362 func (*IpfixFlush) GetMessageName() string { return "ipfix_flush" }
 363 func (*IpfixFlush) GetCrcString() string   { return "51077d14" }
 364 func (*IpfixFlush) GetMessageType() api.MessageType {
 365         return api.RequestMessage
 366 }
 367
 368 func (m *IpfixFlush) Size() int {
 369         if m == nil {
 370                 return 0
 371         }
 372         var size int
 373         return size
 374 }
 375 func (m *IpfixFlush) Marshal(b []byte) ([]byte, error) {
 376         var buf *codec.Buffer
 377         if b == nil {
 378                 buf = codec.NewBuffer(make([]byte, m.Size()))
 379         } else {
 380                 buf = codec.NewBuffer(b)
 381         }
 382         return buf.Bytes(), nil
 383 }
 384 func (m *IpfixFlush) Unmarshal(b []byte) error {
 385         return nil
 386 }
 387
 388 // IpfixFlushReply defines message 'ipfix_flush_reply'.
 389 type IpfixFlushReply struct {
 390         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
 391 }
 392
 393 func (m *IpfixFlushReply) Reset()               { *m = IpfixFlushReply{} }
 394 func (*IpfixFlushReply) GetMessageName() string { return "ipfix_flush_reply" }
 395 func (*IpfixFlushReply) GetCrcString() string   { return "e8d4e804" }
 396 func (*IpfixFlushReply) GetMessageType() api.MessageType {
 397         return api.ReplyMessage
 398 }
 399
 400 func (m *IpfixFlushReply) Size() int {
 401         if m == nil {
 402                 return 0
 403         }
 404         var size int
 405         size += 4 // m.Retval
 406         return size
 407 }
 408 func (m *IpfixFlushReply) Marshal(b []byte) ([]byte, error) {
 409         var buf *codec.Buffer
 410         if b == nil {
 411                 buf = codec.NewBuffer(make([]byte, m.Size()))
 412         } else {
 413                 buf = codec.NewBuffer(b)
 414         }
 415         buf.EncodeUint32(uint32(m.Retval))
 416         return buf.Bytes(), nil
 417 }
 418 func (m *IpfixFlushReply) Unmarshal(b []byte) error {
 419         buf := codec.NewBuffer(b)
 420         m.Retval = int32(buf.DecodeUint32())
 421         return nil
 422 }
 423
 424 // SetIpfixClassifyStream defines message 'set_ipfix_classify_stream'.
 425 type SetIpfixClassifyStream struct {
 426         DomainID uint32 `binapi:"u32,name=domain_id" json:"domain_id,omitempty"`
 427         SrcPort  uint16 `binapi:"u16,name=src_port" json:"src_port,omitempty"`
 428 }
 429
 430 func (m *SetIpfixClassifyStream) Reset()               { *m = SetIpfixClassifyStream{} }
 431 func (*SetIpfixClassifyStream) GetMessageName() string { return "set_ipfix_classify_stream" }
 432 func (*SetIpfixClassifyStream) GetCrcString() string   { return "c9cbe053" }
 433 func (*SetIpfixClassifyStream) GetMessageType() api.MessageType {
 434         return api.RequestMessage
 435 }
 436
 437 func (m *SetIpfixClassifyStream) Size() int {
 438         if m == nil {
 439                 return 0
 440         }
 441         var size int
 442         size += 4 // m.DomainID
 443         size += 2 // m.SrcPort
 444         return size
 445 }
 446 func (m *SetIpfixClassifyStream) Marshal(b []byte) ([]byte, error) {
 447         var buf *codec.Buffer
 448         if b == nil {
 449                 buf = codec.NewBuffer(make([]byte, m.Size()))
 450         } else {
 451                 buf = codec.NewBuffer(b)
 452         }
 453         buf.EncodeUint32(uint32(m.DomainID))
 454         buf.EncodeUint16(uint16(m.SrcPort))
 455         return buf.Bytes(), nil
 456 }
 457 func (m *SetIpfixClassifyStream) Unmarshal(b []byte) error {
 458         buf := codec.NewBuffer(b)
 459         m.DomainID = buf.DecodeUint32()
 460         m.SrcPort = buf.DecodeUint16()
 461         return nil
 462 }
 463
 464 // SetIpfixClassifyStreamReply defines message 'set_ipfix_classify_stream_reply'.
 465 type SetIpfixClassifyStreamReply struct {
 466         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
 467 }
 468
 469 func (m *SetIpfixClassifyStreamReply) Reset()               { *m = SetIpfixClassifyStreamReply{} }
 470 func (*SetIpfixClassifyStreamReply) GetMessageName() string { return "set_ipfix_classify_stream_reply" }
 471 func (*SetIpfixClassifyStreamReply) GetCrcString() string   { return "e8d4e804" }
 472 func (*SetIpfixClassifyStreamReply) GetMessageType() api.MessageType {
 473         return api.ReplyMessage
 474 }
 475
 476 func (m *SetIpfixClassifyStreamReply) Size() int {
 477         if m == nil {
 478                 return 0
 479         }
 480         var size int
 481         size += 4 // m.Retval
 482         return size
 483 }
 484 func (m *SetIpfixClassifyStreamReply) Marshal(b []byte) ([]byte, error) {
 485         var buf *codec.Buffer
 486         if b == nil {
 487                 buf = codec.NewBuffer(make([]byte, m.Size()))
 488         } else {
 489                 buf = codec.NewBuffer(b)
 490         }
 491         buf.EncodeUint32(uint32(m.Retval))
 492         return buf.Bytes(), nil
 493 }
 494 func (m *SetIpfixClassifyStreamReply) Unmarshal(b []byte) error {
 495         buf := codec.NewBuffer(b)
 496         m.Retval = int32(buf.DecodeUint32())
 497         return nil
 498 }
 499
 500 // SetIpfixExporter defines message 'set_ipfix_exporter'.
 501 type SetIpfixExporter struct {
 502         CollectorAddress ip_types.Address `binapi:"address,name=collector_address" json:"collector_address,omitempty"`
 503         CollectorPort    uint16           `binapi:"u16,name=collector_port" json:"collector_port,omitempty"`
 504         SrcAddress       ip_types.Address `binapi:"address,name=src_address" json:"src_address,omitempty"`
 505         VrfID            uint32           `binapi:"u32,name=vrf_id" json:"vrf_id,omitempty"`
 506         PathMtu          uint32           `binapi:"u32,name=path_mtu" json:"path_mtu,omitempty"`
 507         TemplateInterval uint32           `binapi:"u32,name=template_interval" json:"template_interval,omitempty"`
 508         UDPChecksum      bool             `binapi:"bool,name=udp_checksum" json:"udp_checksum,omitempty"`
 509 }
 510
 511 func (m *SetIpfixExporter) Reset()               { *m = SetIpfixExporter{} }
 512 func (*SetIpfixExporter) GetMessageName() string { return "set_ipfix_exporter" }
 513 func (*SetIpfixExporter) GetCrcString() string   { return "69284e07" }
 514 func (*SetIpfixExporter) GetMessageType() api.MessageType {
 515         return api.RequestMessage
 516 }
 517
 518 func (m *SetIpfixExporter) Size() int {
 519         if m == nil {
 520                 return 0
 521         }
 522         var size int
 523         size += 1      // m.CollectorAddress.Af
 524         size += 1 * 16 // m.CollectorAddress.Un
 525         size += 2      // m.CollectorPort
 526         size += 1      // m.SrcAddress.Af
 527         size += 1 * 16 // m.SrcAddress.Un
 528         size += 4      // m.VrfID
 529         size += 4      // m.PathMtu
 530         size += 4      // m.TemplateInterval
 531         size += 1      // m.UDPChecksum
 532         return size
 533 }
 534 func (m *SetIpfixExporter) Marshal(b []byte) ([]byte, error) {
 535         var buf *codec.Buffer
 536         if b == nil {
 537                 buf = codec.NewBuffer(make([]byte, m.Size()))
 538         } else {
 539                 buf = codec.NewBuffer(b)
 540         }
 541         buf.EncodeUint8(uint8(m.CollectorAddress.Af))
 542         buf.EncodeBytes(m.CollectorAddress.Un.XXX_UnionData[:], 0)
 543         buf.EncodeUint16(uint16(m.CollectorPort))
 544         buf.EncodeUint8(uint8(m.SrcAddress.Af))
 545         buf.EncodeBytes(m.SrcAddress.Un.XXX_UnionData[:], 0)
 546         buf.EncodeUint32(uint32(m.VrfID))
 547         buf.EncodeUint32(uint32(m.PathMtu))
 548         buf.EncodeUint32(uint32(m.TemplateInterval))
 549         buf.EncodeBool(m.UDPChecksum)
 550         return buf.Bytes(), nil
 551 }
 552 func (m *SetIpfixExporter) Unmarshal(b []byte) error {
 553         buf := codec.NewBuffer(b)
 554         m.CollectorAddress.Af = ip_types.AddressFamily(buf.DecodeUint8())
 555         copy(m.CollectorAddress.Un.XXX_UnionData[:], buf.DecodeBytes(16))
 556         m.CollectorPort = buf.DecodeUint16()
 557         m.SrcAddress.Af = ip_types.AddressFamily(buf.DecodeUint8())
 558         copy(m.SrcAddress.Un.XXX_UnionData[:], buf.DecodeBytes(16))
 559         m.VrfID = buf.DecodeUint32()
 560         m.PathMtu = buf.DecodeUint32()
 561         m.TemplateInterval = buf.DecodeUint32()
 562         m.UDPChecksum = buf.DecodeBool()
 563         return nil
 564 }
 565
 566 // SetIpfixExporterReply defines message 'set_ipfix_exporter_reply'.
 567 type SetIpfixExporterReply struct {
 568         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
 569 }
 570
 571 func (m *SetIpfixExporterReply) Reset()               { *m = SetIpfixExporterReply{} }
 572 func (*SetIpfixExporterReply) GetMessageName() string { return "set_ipfix_exporter_reply" }
 573 func (*SetIpfixExporterReply) GetCrcString() string   { return "e8d4e804" }
 574 func (*SetIpfixExporterReply) GetMessageType() api.MessageType {
 575         return api.ReplyMessage
 576 }
 577
 578 func (m *SetIpfixExporterReply) Size() int {
 579         if m == nil {
 580                 return 0
 581         }
 582         var size int
 583         size += 4 // m.Retval
 584         return size
 585 }
 586 func (m *SetIpfixExporterReply) Marshal(b []byte) ([]byte, error) {
 587         var buf *codec.Buffer
 588         if b == nil {
 589                 buf = codec.NewBuffer(make([]byte, m.Size()))
 590         } else {
 591                 buf = codec.NewBuffer(b)
 592         }
 593         buf.EncodeUint32(uint32(m.Retval))
 594         return buf.Bytes(), nil
 595 }
 596 func (m *SetIpfixExporterReply) Unmarshal(b []byte) error {
 597         buf := codec.NewBuffer(b)
 598         m.Retval = int32(buf.DecodeUint32())
 599         return nil
 600 }
 601
 602 func init() { file_ipfix_export_binapi_init() }
 603 func file_ipfix_export_binapi_init() {
 604         api.RegisterMessage((*IpfixClassifyStreamDetails)(nil), "ipfix_classify_stream_details_2903539d")
 605         api.RegisterMessage((*IpfixClassifyStreamDump)(nil), "ipfix_classify_stream_dump_51077d14")
 606         api.RegisterMessage((*IpfixClassifyTableAddDel)(nil), "ipfix_classify_table_add_del_3e449bb9")
 607         api.RegisterMessage((*IpfixClassifyTableAddDelReply)(nil), "ipfix_classify_table_add_del_reply_e8d4e804")
 608         api.RegisterMessage((*IpfixClassifyTableDetails)(nil), "ipfix_classify_table_details_1af8c28c")
 609         api.RegisterMessage((*IpfixClassifyTableDump)(nil), "ipfix_classify_table_dump_51077d14")
 610         api.RegisterMessage((*IpfixExporterDetails)(nil), "ipfix_exporter_details_11e07413")
 611         api.RegisterMessage((*IpfixExporterDump)(nil), "ipfix_exporter_dump_51077d14")
 612         api.RegisterMessage((*IpfixFlush)(nil), "ipfix_flush_51077d14")
 613         api.RegisterMessage((*IpfixFlushReply)(nil), "ipfix_flush_reply_e8d4e804")
 614         api.RegisterMessage((*SetIpfixClassifyStream)(nil), "set_ipfix_classify_stream_c9cbe053")
 615         api.RegisterMessage((*SetIpfixClassifyStreamReply)(nil), "set_ipfix_classify_stream_reply_e8d4e804")
 616         api.RegisterMessage((*SetIpfixExporter)(nil), "set_ipfix_exporter_69284e07")
 617         api.RegisterMessage((*SetIpfixExporterReply)(nil), "set_ipfix_exporter_reply_e8d4e804")
 618 }
 619
 620 // Messages returns list of all messages in this module.
 621 func AllMessages() []api.Message {
 622         return []api.Message{
 623                 (*IpfixClassifyStreamDetails)(nil),
 624                 (*IpfixClassifyStreamDump)(nil),
 625                 (*IpfixClassifyTableAddDel)(nil),
 626                 (*IpfixClassifyTableAddDelReply)(nil),
 627                 (*IpfixClassifyTableDetails)(nil),
 628                 (*IpfixClassifyTableDump)(nil),
 629                 (*IpfixExporterDetails)(nil),
 630                 (*IpfixExporterDump)(nil),
 631                 (*IpfixFlush)(nil),
 632                 (*IpfixFlushReply)(nil),
 633                 (*SetIpfixClassifyStream)(nil),
 634                 (*SetIpfixClassifyStreamReply)(nil),
 635                 (*SetIpfixExporter)(nil),
 636                 (*SetIpfixExporterReply)(nil),
 637         }
 638 }