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