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