internal/testbinapi/binapi2001/ipfix_export/ipfix_export.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/ipfix_export.api.json
   6
   7 // Package ipfix_export contains generated bindings for API file ipfix_export.api.
   8 //
   9 // Contents:
  10 //   5 aliases
  11 //   4 enums
  12 //   6 structs
  13 //   1 union
  14 //  14 messages
  15 //
  16 package ipfix_export
  17
  18 import (
  19         "fmt"
  20         "net"
  21         "strconv"
  22         "strings"
  23
  24         api "git.fd.io/govpp.git/api"
  25         codec "git.fd.io/govpp.git/codec"
  26 )
  27
  28 // This is a compile-time assertion to ensure that this generated file
  29 // is compatible with the GoVPP api package it is being compiled against.
  30 // A compilation error at this line likely means your copy of the
  31 // GoVPP api package needs to be updated.
  32 const _ = api.GoVppAPIPackageIsVersion2
  33
  34 const (
  35         APIFile    = "ipfix_export"
  36         APIVersion = "2.0.1"
  37         VersionCrc = 0xee6ea488
  38 )
  39
  40 // AddressFamily defines enum 'address_family'.
  41 type AddressFamily uint32
  42
  43 const (
  44         ADDRESS_IP4 AddressFamily = 0
  45         ADDRESS_IP6 AddressFamily = 1
  46 )
  47
  48 var (
  49         AddressFamily_name = map[uint32]string{
  50                 0: "ADDRESS_IP4",
  51                 1: "ADDRESS_IP6",
  52         }
  53         AddressFamily_value = map[string]uint32{
  54                 "ADDRESS_IP4": 0,
  55                 "ADDRESS_IP6": 1,
  56         }
  57 )
  58
  59 func (x AddressFamily) String() string {
  60         s, ok := AddressFamily_name[uint32(x)]
  61         if ok {
  62                 return s
  63         }
  64         return "AddressFamily(" + strconv.Itoa(int(x)) + ")"
  65 }
  66
  67 // IPDscp defines enum 'ip_dscp'.
  68 type IPDscp uint8
  69
  70 const (
  71         IP_API_DSCP_CS0  IPDscp = 0
  72         IP_API_DSCP_CS1  IPDscp = 8
  73         IP_API_DSCP_AF11 IPDscp = 10
  74         IP_API_DSCP_AF12 IPDscp = 12
  75         IP_API_DSCP_AF13 IPDscp = 14
  76         IP_API_DSCP_CS2  IPDscp = 16
  77         IP_API_DSCP_AF21 IPDscp = 18
  78         IP_API_DSCP_AF22 IPDscp = 20
  79         IP_API_DSCP_AF23 IPDscp = 22
  80         IP_API_DSCP_CS3  IPDscp = 24
  81         IP_API_DSCP_AF31 IPDscp = 26
  82         IP_API_DSCP_AF32 IPDscp = 28
  83         IP_API_DSCP_AF33 IPDscp = 30
  84         IP_API_DSCP_CS4  IPDscp = 32
  85         IP_API_DSCP_AF41 IPDscp = 34
  86         IP_API_DSCP_AF42 IPDscp = 36
  87         IP_API_DSCP_AF43 IPDscp = 38
  88         IP_API_DSCP_CS5  IPDscp = 40
  89         IP_API_DSCP_EF   IPDscp = 46
  90         IP_API_DSCP_CS6  IPDscp = 48
  91         IP_API_DSCP_CS7  IPDscp = 50
  92 )
  93
  94 var (
  95         IPDscp_name = map[uint8]string{
  96                 0:  "IP_API_DSCP_CS0",
  97                 8:  "IP_API_DSCP_CS1",
  98                 10: "IP_API_DSCP_AF11",
  99                 12: "IP_API_DSCP_AF12",
 100                 14: "IP_API_DSCP_AF13",
 101                 16: "IP_API_DSCP_CS2",
 102                 18: "IP_API_DSCP_AF21",
 103                 20: "IP_API_DSCP_AF22",
 104                 22: "IP_API_DSCP_AF23",
 105                 24: "IP_API_DSCP_CS3",
 106                 26: "IP_API_DSCP_AF31",
 107                 28: "IP_API_DSCP_AF32",
 108                 30: "IP_API_DSCP_AF33",
 109                 32: "IP_API_DSCP_CS4",
 110                 34: "IP_API_DSCP_AF41",
 111                 36: "IP_API_DSCP_AF42",
 112                 38: "IP_API_DSCP_AF43",
 113                 40: "IP_API_DSCP_CS5",
 114                 46: "IP_API_DSCP_EF",
 115                 48: "IP_API_DSCP_CS6",
 116                 50: "IP_API_DSCP_CS7",
 117         }
 118         IPDscp_value = map[string]uint8{
 119                 "IP_API_DSCP_CS0":  0,
 120                 "IP_API_DSCP_CS1":  8,
 121                 "IP_API_DSCP_AF11": 10,
 122                 "IP_API_DSCP_AF12": 12,
 123                 "IP_API_DSCP_AF13": 14,
 124                 "IP_API_DSCP_CS2":  16,
 125                 "IP_API_DSCP_AF21": 18,
 126                 "IP_API_DSCP_AF22": 20,
 127                 "IP_API_DSCP_AF23": 22,
 128                 "IP_API_DSCP_CS3":  24,
 129                 "IP_API_DSCP_AF31": 26,
 130                 "IP_API_DSCP_AF32": 28,
 131                 "IP_API_DSCP_AF33": 30,
 132                 "IP_API_DSCP_CS4":  32,
 133                 "IP_API_DSCP_AF41": 34,
 134                 "IP_API_DSCP_AF42": 36,
 135                 "IP_API_DSCP_AF43": 38,
 136                 "IP_API_DSCP_CS5":  40,
 137                 "IP_API_DSCP_EF":   46,
 138                 "IP_API_DSCP_CS6":  48,
 139                 "IP_API_DSCP_CS7":  50,
 140         }
 141 )
 142
 143 func (x IPDscp) String() string {
 144         s, ok := IPDscp_name[uint8(x)]
 145         if ok {
 146                 return s
 147         }
 148         return "IPDscp(" + strconv.Itoa(int(x)) + ")"
 149 }
 150
 151 // IPEcn defines enum 'ip_ecn'.
 152 type IPEcn uint8
 153
 154 const (
 155         IP_API_ECN_NONE IPEcn = 0
 156         IP_API_ECN_ECT0 IPEcn = 1
 157         IP_API_ECN_ECT1 IPEcn = 2
 158         IP_API_ECN_CE   IPEcn = 3
 159 )
 160
 161 var (
 162         IPEcn_name = map[uint8]string{
 163                 0: "IP_API_ECN_NONE",
 164                 1: "IP_API_ECN_ECT0",
 165                 2: "IP_API_ECN_ECT1",
 166                 3: "IP_API_ECN_CE",
 167         }
 168         IPEcn_value = map[string]uint8{
 169                 "IP_API_ECN_NONE": 0,
 170                 "IP_API_ECN_ECT0": 1,
 171                 "IP_API_ECN_ECT1": 2,
 172                 "IP_API_ECN_CE":   3,
 173         }
 174 )
 175
 176 func (x IPEcn) String() string {
 177         s, ok := IPEcn_name[uint8(x)]
 178         if ok {
 179                 return s
 180         }
 181         return "IPEcn(" + strconv.Itoa(int(x)) + ")"
 182 }
 183
 184 // IPProto defines enum 'ip_proto'.
 185 type IPProto uint32
 186
 187 const (
 188         IP_API_PROTO_HOPOPT   IPProto = 0
 189         IP_API_PROTO_ICMP     IPProto = 1
 190         IP_API_PROTO_IGMP     IPProto = 2
 191         IP_API_PROTO_TCP      IPProto = 6
 192         IP_API_PROTO_UDP      IPProto = 17
 193         IP_API_PROTO_GRE      IPProto = 47
 194         IP_API_PROTO_AH       IPProto = 50
 195         IP_API_PROTO_ESP      IPProto = 51
 196         IP_API_PROTO_EIGRP    IPProto = 88
 197         IP_API_PROTO_OSPF     IPProto = 89
 198         IP_API_PROTO_SCTP     IPProto = 132
 199         IP_API_PROTO_RESERVED IPProto = 255
 200 )
 201
 202 var (
 203         IPProto_name = map[uint32]string{
 204                 0:   "IP_API_PROTO_HOPOPT",
 205                 1:   "IP_API_PROTO_ICMP",
 206                 2:   "IP_API_PROTO_IGMP",
 207                 6:   "IP_API_PROTO_TCP",
 208                 17:  "IP_API_PROTO_UDP",
 209                 47:  "IP_API_PROTO_GRE",
 210                 50:  "IP_API_PROTO_AH",
 211                 51:  "IP_API_PROTO_ESP",
 212                 88:  "IP_API_PROTO_EIGRP",
 213                 89:  "IP_API_PROTO_OSPF",
 214                 132: "IP_API_PROTO_SCTP",
 215                 255: "IP_API_PROTO_RESERVED",
 216         }
 217         IPProto_value = map[string]uint32{
 218                 "IP_API_PROTO_HOPOPT":   0,
 219                 "IP_API_PROTO_ICMP":     1,
 220                 "IP_API_PROTO_IGMP":     2,
 221                 "IP_API_PROTO_TCP":      6,
 222                 "IP_API_PROTO_UDP":      17,
 223                 "IP_API_PROTO_GRE":      47,
 224                 "IP_API_PROTO_AH":       50,
 225                 "IP_API_PROTO_ESP":      51,
 226                 "IP_API_PROTO_EIGRP":    88,
 227                 "IP_API_PROTO_OSPF":     89,
 228                 "IP_API_PROTO_SCTP":     132,
 229                 "IP_API_PROTO_RESERVED": 255,
 230         }
 231 )
 232
 233 func (x IPProto) String() string {
 234         s, ok := IPProto_name[uint32(x)]
 235         if ok {
 236                 return s
 237         }
 238         return "IPProto(" + strconv.Itoa(int(x)) + ")"
 239 }
 240
 241 // AddressWithPrefix defines alias 'address_with_prefix'.
 242 type AddressWithPrefix Prefix
 243
 244 func ParseAddressWithPrefix(s string) (AddressWithPrefix, error) {
 245         prefix, err := ParsePrefix(s)
 246         if err != nil {
 247                 return AddressWithPrefix{}, err
 248         }
 249         return AddressWithPrefix(prefix), nil
 250 }
 251
 252 func (x AddressWithPrefix) String() string {
 253         return Prefix(x).String()
 254 }
 255
 256 func (x *AddressWithPrefix) MarshalText() ([]byte, error) {
 257         return []byte(x.String()), nil
 258 }
 259
 260 func (x *AddressWithPrefix) UnmarshalText(text []byte) error {
 261         prefix, err := ParseAddressWithPrefix(string(text))
 262         if err != nil {
 263                 return err
 264         }
 265         *x = prefix
 266         return nil
 267 }
 268
 269 // IP4Address defines alias 'ip4_address'.
 270 type IP4Address [4]uint8
 271
 272 func ParseIP4Address(s string) (IP4Address, error) {
 273         ip := net.ParseIP(s).To4()
 274         if ip == nil {
 275                 return IP4Address{}, fmt.Errorf("invalid IP address: %s", s)
 276         }
 277         var ipaddr IP4Address
 278         copy(ipaddr[:], ip.To4())
 279         return ipaddr, nil
 280 }
 281
 282 func (x IP4Address) ToIP() net.IP {
 283         return net.IP(x[:]).To4()
 284 }
 285
 286 func (x IP4Address) String() string {
 287         return x.ToIP().String()
 288 }
 289
 290 func (x *IP4Address) MarshalText() ([]byte, error) {
 291         return []byte(x.String()), nil
 292 }
 293
 294 func (x *IP4Address) UnmarshalText(text []byte) error {
 295         ipaddr, err := ParseIP4Address(string(text))
 296         if err != nil {
 297                 return err
 298         }
 299         *x = ipaddr
 300         return nil
 301 }
 302
 303 // IP4AddressWithPrefix defines alias 'ip4_address_with_prefix'.
 304 type IP4AddressWithPrefix IP4Prefix
 305
 306 // IP6Address defines alias 'ip6_address'.
 307 type IP6Address [16]uint8
 308
 309 func ParseIP6Address(s string) (IP6Address, error) {
 310         ip := net.ParseIP(s).To16()
 311         if ip == nil {
 312                 return IP6Address{}, fmt.Errorf("invalid IP address: %s", s)
 313         }
 314         var ipaddr IP6Address
 315         copy(ipaddr[:], ip.To16())
 316         return ipaddr, nil
 317 }
 318
 319 func (x IP6Address) ToIP() net.IP {
 320         return net.IP(x[:]).To16()
 321 }
 322
 323 func (x IP6Address) String() string {
 324         return x.ToIP().String()
 325 }
 326
 327 func (x *IP6Address) MarshalText() ([]byte, error) {
 328         return []byte(x.String()), nil
 329 }
 330
 331 func (x *IP6Address) UnmarshalText(text []byte) error {
 332         ipaddr, err := ParseIP6Address(string(text))
 333         if err != nil {
 334                 return err
 335         }
 336         *x = ipaddr
 337         return nil
 338 }
 339
 340 // IP6AddressWithPrefix defines alias 'ip6_address_with_prefix'.
 341 type IP6AddressWithPrefix IP6Prefix
 342
 343 // Address defines type 'address'.
 344 type Address struct {
 345         Af AddressFamily `binapi:"address_family,name=af" json:"af,omitempty"`
 346         Un AddressUnion  `binapi:"address_union,name=un" json:"un,omitempty"`
 347 }
 348
 349 func ParseAddress(s string) (Address, error) {
 350         ip := net.ParseIP(s)
 351         if ip == nil {
 352                 return Address{}, fmt.Errorf("invalid address: %s", s)
 353         }
 354         return AddressFromIP(ip), nil
 355 }
 356
 357 func AddressFromIP(ip net.IP) Address {
 358         var addr Address
 359         if ip.To4() == nil {
 360                 addr.Af = ADDRESS_IP6
 361                 var ip6 IP6Address
 362                 copy(ip6[:], ip.To16())
 363                 addr.Un.SetIP6(ip6)
 364         } else {
 365                 addr.Af = ADDRESS_IP4
 366                 var ip4 IP4Address
 367                 copy(ip4[:], ip.To4())
 368                 addr.Un.SetIP4(ip4)
 369         }
 370         return addr
 371 }
 372
 373 func (x Address) ToIP() net.IP {
 374         if x.Af == ADDRESS_IP6 {
 375                 ip6 := x.Un.GetIP6()
 376                 return net.IP(ip6[:]).To16()
 377         } else {
 378                 ip4 := x.Un.GetIP4()
 379                 return net.IP(ip4[:]).To4()
 380         }
 381 }
 382
 383 func (x Address) String() string {
 384         return x.ToIP().String()
 385 }
 386
 387 func (x *Address) MarshalText() ([]byte, error) {
 388         return []byte(x.String()), nil
 389 }
 390
 391 func (x *Address) UnmarshalText(text []byte) error {
 392         addr, err := ParseAddress(string(text))
 393         if err != nil {
 394                 return err
 395         }
 396         *x = addr
 397         return nil
 398 }
 399
 400 // IP4Prefix defines type 'ip4_prefix'.
 401 type IP4Prefix struct {
 402         Address IP4Address `binapi:"ip4_address,name=address" json:"address,omitempty"`
 403         Len     uint8      `binapi:"u8,name=len" json:"len,omitempty"`
 404 }
 405
 406 func ParseIP4Prefix(s string) (prefix IP4Prefix, err error) {
 407         hasPrefix := strings.Contains(s, "/")
 408         if hasPrefix {
 409                 ip, network, err := net.ParseCIDR(s)
 410                 if err != nil {
 411                         return IP4Prefix{}, fmt.Errorf("invalid IP %s: %s", s, err)
 412                 }
 413                 maskSize, _ := network.Mask.Size()
 414                 prefix.Len = byte(maskSize)
 415                 prefix.Address, err = ParseIP4Address(ip.String())
 416                 if err != nil {
 417                         return IP4Prefix{}, fmt.Errorf("invalid IP %s: %s", s, err)
 418                 }
 419         } else {
 420                 ip := net.ParseIP(s)
 421                 defaultMaskSize, _ := net.CIDRMask(32, 32).Size()
 422                 if ip.To4() == nil {
 423                         defaultMaskSize, _ = net.CIDRMask(128, 128).Size()
 424                 }
 425                 prefix.Len = byte(defaultMaskSize)
 426                 prefix.Address, err = ParseIP4Address(ip.String())
 427                 if err != nil {
 428                         return IP4Prefix{}, fmt.Errorf("invalid IP %s: %s", s, err)
 429                 }
 430         }
 431         return prefix, nil
 432 }
 433
 434 func (x IP4Prefix) ToIPNet() *net.IPNet {
 435         mask := net.CIDRMask(int(x.Len), 32)
 436         ipnet := &net.IPNet{IP: x.Address.ToIP(), Mask: mask}
 437         return ipnet
 438 }
 439
 440 func (x IP4Prefix) String() string {
 441         ip := x.Address.String()
 442         return ip + "/" + strconv.Itoa(int(x.Len))
 443 }
 444
 445 func (x *IP4Prefix) MarshalText() ([]byte, error) {
 446         return []byte(x.String()), nil
 447 }
 448
 449 func (x *IP4Prefix) UnmarshalText(text []byte) error {
 450         prefix, err := ParseIP4Prefix(string(text))
 451         if err != nil {
 452                 return err
 453         }
 454         *x = prefix
 455         return nil
 456 }
 457
 458 // IP6Prefix defines type 'ip6_prefix'.
 459 type IP6Prefix struct {
 460         Address IP6Address `binapi:"ip6_address,name=address" json:"address,omitempty"`
 461         Len     uint8      `binapi:"u8,name=len" json:"len,omitempty"`
 462 }
 463
 464 func ParseIP6Prefix(s string) (prefix IP6Prefix, err error) {
 465         hasPrefix := strings.Contains(s, "/")
 466         if hasPrefix {
 467                 ip, network, err := net.ParseCIDR(s)
 468                 if err != nil {
 469                         return IP6Prefix{}, fmt.Errorf("invalid IP %s: %s", s, err)
 470                 }
 471                 maskSize, _ := network.Mask.Size()
 472                 prefix.Len = byte(maskSize)
 473                 prefix.Address, err = ParseIP6Address(ip.String())
 474                 if err != nil {
 475                         return IP6Prefix{}, fmt.Errorf("invalid IP %s: %s", s, err)
 476                 }
 477         } else {
 478                 ip := net.ParseIP(s)
 479                 defaultMaskSize, _ := net.CIDRMask(32, 32).Size()
 480                 if ip.To4() == nil {
 481                         defaultMaskSize, _ = net.CIDRMask(128, 128).Size()
 482                 }
 483                 prefix.Len = byte(defaultMaskSize)
 484                 prefix.Address, err = ParseIP6Address(ip.String())
 485                 if err != nil {
 486                         return IP6Prefix{}, fmt.Errorf("invalid IP %s: %s", s, err)
 487                 }
 488         }
 489         return prefix, nil
 490 }
 491
 492 func (x IP6Prefix) ToIPNet() *net.IPNet {
 493         mask := net.CIDRMask(int(x.Len), 128)
 494         ipnet := &net.IPNet{IP: x.Address.ToIP(), Mask: mask}
 495         return ipnet
 496 }
 497
 498 func (x IP6Prefix) String() string {
 499         ip := x.Address.String()
 500         return ip + "/" + strconv.Itoa(int(x.Len))
 501 }
 502
 503 func (x *IP6Prefix) MarshalText() ([]byte, error) {
 504         return []byte(x.String()), nil
 505 }
 506
 507 func (x *IP6Prefix) UnmarshalText(text []byte) error {
 508         prefix, err := ParseIP6Prefix(string(text))
 509         if err != nil {
 510                 return err
 511         }
 512         *x = prefix
 513         return nil
 514 }
 515
 516 // Mprefix defines type 'mprefix'.
 517 type Mprefix struct {
 518         Af               AddressFamily `binapi:"address_family,name=af" json:"af,omitempty"`
 519         GrpAddressLength uint16        `binapi:"u16,name=grp_address_length" json:"grp_address_length,omitempty"`
 520         GrpAddress       AddressUnion  `binapi:"address_union,name=grp_address" json:"grp_address,omitempty"`
 521         SrcAddress       AddressUnion  `binapi:"address_union,name=src_address" json:"src_address,omitempty"`
 522 }
 523
 524 // Prefix defines type 'prefix'.
 525 type Prefix struct {
 526         Address Address `binapi:"address,name=address" json:"address,omitempty"`
 527         Len     uint8   `binapi:"u8,name=len" json:"len,omitempty"`
 528 }
 529
 530 func ParsePrefix(ip string) (prefix Prefix, err error) {
 531         hasPrefix := strings.Contains(ip, "/")
 532         if hasPrefix {
 533                 netIP, network, err := net.ParseCIDR(ip)
 534                 if err != nil {
 535                         return Prefix{}, fmt.Errorf("invalid IP %s: %s", ip, err)
 536                 }
 537                 maskSize, _ := network.Mask.Size()
 538                 prefix.Len = byte(maskSize)
 539                 prefix.Address, err = ParseAddress(netIP.String())
 540                 if err != nil {
 541                         return Prefix{}, fmt.Errorf("invalid IP %s: %s", ip, err)
 542                 }
 543         } else {
 544                 netIP := net.ParseIP(ip)
 545                 defaultMaskSize, _ := net.CIDRMask(32, 32).Size()
 546                 if netIP.To4() == nil {
 547                         defaultMaskSize, _ = net.CIDRMask(128, 128).Size()
 548                 }
 549                 prefix.Len = byte(defaultMaskSize)
 550                 prefix.Address, err = ParseAddress(netIP.String())
 551                 if err != nil {
 552                         return Prefix{}, fmt.Errorf("invalid IP %s: %s", ip, err)
 553                 }
 554         }
 555         return prefix, nil
 556 }
 557
 558 func (x Prefix) ToIPNet() *net.IPNet {
 559         var mask net.IPMask
 560         if x.Address.Af == ADDRESS_IP4 {
 561                 mask = net.CIDRMask(int(x.Len), 32)
 562         } else {
 563                 mask = net.CIDRMask(int(x.Len), 128)
 564         }
 565         ipnet := &net.IPNet{IP: x.Address.ToIP(), Mask: mask}
 566         return ipnet
 567 }
 568
 569 func (x Prefix) String() string {
 570         ip := x.Address.String()
 571         return ip + "/" + strconv.Itoa(int(x.Len))
 572 }
 573
 574 func (x *Prefix) MarshalText() ([]byte, error) {
 575         return []byte(x.String()), nil
 576 }
 577
 578 func (x *Prefix) UnmarshalText(text []byte) error {
 579         prefix, err := ParsePrefix(string(text))
 580         if err != nil {
 581                 return err
 582         }
 583         *x = prefix
 584         return nil
 585 }
 586
 587 // PrefixMatcher defines type 'prefix_matcher'.
 588 type PrefixMatcher struct {
 589         Le uint8 `binapi:"u8,name=le" json:"le,omitempty"`
 590         Ge uint8 `binapi:"u8,name=ge" json:"ge,omitempty"`
 591 }
 592
 593 // AddressUnion defines union 'address_union'.
 594 type AddressUnion struct {
 595         // AddressUnion can be one of:
 596         // - IP4 *IP4Address
 597         // - IP6 *IP6Address
 598         XXX_UnionData [16]byte
 599 }
 600
 601 func AddressUnionIP4(a IP4Address) (u AddressUnion) {
 602         u.SetIP4(a)
 603         return
 604 }
 605 func (u *AddressUnion) SetIP4(a IP4Address) {
 606         buf := codec.NewBuffer(u.XXX_UnionData[:])
 607         buf.EncodeBytes(a[:], 4)
 608 }
 609 func (u *AddressUnion) GetIP4() (a IP4Address) {
 610         buf := codec.NewBuffer(u.XXX_UnionData[:])
 611         copy(a[:], buf.DecodeBytes(4))
 612         return
 613 }
 614
 615 func AddressUnionIP6(a IP6Address) (u AddressUnion) {
 616         u.SetIP6(a)
 617         return
 618 }
 619 func (u *AddressUnion) SetIP6(a IP6Address) {
 620         buf := codec.NewBuffer(u.XXX_UnionData[:])
 621         buf.EncodeBytes(a[:], 16)
 622 }
 623 func (u *AddressUnion) GetIP6() (a IP6Address) {
 624         buf := codec.NewBuffer(u.XXX_UnionData[:])
 625         copy(a[:], buf.DecodeBytes(16))
 626         return
 627 }
 628
 629 // IpfixClassifyStreamDetails defines message 'ipfix_classify_stream_details'.
 630 type IpfixClassifyStreamDetails struct {
 631         DomainID uint32 `binapi:"u32,name=domain_id" json:"domain_id,omitempty"`
 632         SrcPort  uint16 `binapi:"u16,name=src_port" json:"src_port,omitempty"`
 633 }
 634
 635 func (m *IpfixClassifyStreamDetails) Reset()               { *m = IpfixClassifyStreamDetails{} }
 636 func (*IpfixClassifyStreamDetails) GetMessageName() string { return "ipfix_classify_stream_details" }
 637 func (*IpfixClassifyStreamDetails) GetCrcString() string   { return "2903539d" }
 638 func (*IpfixClassifyStreamDetails) GetMessageType() api.MessageType {
 639         return api.ReplyMessage
 640 }
 641
 642 func (m *IpfixClassifyStreamDetails) Size() (size int) {
 643         if m == nil {
 644                 return 0
 645         }
 646         size += 4 // m.DomainID
 647         size += 2 // m.SrcPort
 648         return size
 649 }
 650 func (m *IpfixClassifyStreamDetails) Marshal(b []byte) ([]byte, error) {
 651         if b == nil {
 652                 b = make([]byte, m.Size())
 653         }
 654         buf := codec.NewBuffer(b)
 655         buf.EncodeUint32(m.DomainID)
 656         buf.EncodeUint16(m.SrcPort)
 657         return buf.Bytes(), nil
 658 }
 659 func (m *IpfixClassifyStreamDetails) Unmarshal(b []byte) error {
 660         buf := codec.NewBuffer(b)
 661         m.DomainID = buf.DecodeUint32()
 662         m.SrcPort = buf.DecodeUint16()
 663         return nil
 664 }
 665
 666 // IpfixClassifyStreamDump defines message 'ipfix_classify_stream_dump'.
 667 type IpfixClassifyStreamDump struct{}
 668
 669 func (m *IpfixClassifyStreamDump) Reset()               { *m = IpfixClassifyStreamDump{} }
 670 func (*IpfixClassifyStreamDump) GetMessageName() string { return "ipfix_classify_stream_dump" }
 671 func (*IpfixClassifyStreamDump) GetCrcString() string   { return "51077d14" }
 672 func (*IpfixClassifyStreamDump) GetMessageType() api.MessageType {
 673         return api.RequestMessage
 674 }
 675
 676 func (m *IpfixClassifyStreamDump) Size() (size int) {
 677         if m == nil {
 678                 return 0
 679         }
 680         return size
 681 }
 682 func (m *IpfixClassifyStreamDump) Marshal(b []byte) ([]byte, error) {
 683         if b == nil {
 684                 b = make([]byte, m.Size())
 685         }
 686         buf := codec.NewBuffer(b)
 687         return buf.Bytes(), nil
 688 }
 689 func (m *IpfixClassifyStreamDump) Unmarshal(b []byte) error {
 690         return nil
 691 }
 692
 693 // IpfixClassifyTableAddDel defines message 'ipfix_classify_table_add_del'.
 694 type IpfixClassifyTableAddDel struct {
 695         TableID           uint32        `binapi:"u32,name=table_id" json:"table_id,omitempty"`
 696         IPVersion         AddressFamily `binapi:"address_family,name=ip_version" json:"ip_version,omitempty"`
 697         TransportProtocol IPProto       `binapi:"ip_proto,name=transport_protocol" json:"transport_protocol,omitempty"`
 698         IsAdd             bool          `binapi:"bool,name=is_add" json:"is_add,omitempty"`
 699 }
 700
 701 func (m *IpfixClassifyTableAddDel) Reset()               { *m = IpfixClassifyTableAddDel{} }
 702 func (*IpfixClassifyTableAddDel) GetMessageName() string { return "ipfix_classify_table_add_del" }
 703 func (*IpfixClassifyTableAddDel) GetCrcString() string   { return "5118bc5e" }
 704 func (*IpfixClassifyTableAddDel) GetMessageType() api.MessageType {
 705         return api.RequestMessage
 706 }
 707
 708 func (m *IpfixClassifyTableAddDel) Size() (size int) {
 709         if m == nil {
 710                 return 0
 711         }
 712         size += 4 // m.TableID
 713         size += 4 // m.IPVersion
 714         size += 4 // m.TransportProtocol
 715         size += 1 // m.IsAdd
 716         return size
 717 }
 718 func (m *IpfixClassifyTableAddDel) Marshal(b []byte) ([]byte, error) {
 719         if b == nil {
 720                 b = make([]byte, m.Size())
 721         }
 722         buf := codec.NewBuffer(b)
 723         buf.EncodeUint32(m.TableID)
 724         buf.EncodeUint32(uint32(m.IPVersion))
 725         buf.EncodeUint32(uint32(m.TransportProtocol))
 726         buf.EncodeBool(m.IsAdd)
 727         return buf.Bytes(), nil
 728 }
 729 func (m *IpfixClassifyTableAddDel) Unmarshal(b []byte) error {
 730         buf := codec.NewBuffer(b)
 731         m.TableID = buf.DecodeUint32()
 732         m.IPVersion = AddressFamily(buf.DecodeUint32())
 733         m.TransportProtocol = IPProto(buf.DecodeUint32())
 734         m.IsAdd = buf.DecodeBool()
 735         return nil
 736 }
 737
 738 // IpfixClassifyTableAddDelReply defines message 'ipfix_classify_table_add_del_reply'.
 739 type IpfixClassifyTableAddDelReply struct {
 740         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
 741 }
 742
 743 func (m *IpfixClassifyTableAddDelReply) Reset() { *m = IpfixClassifyTableAddDelReply{} }
 744 func (*IpfixClassifyTableAddDelReply) GetMessageName() string {
 745         return "ipfix_classify_table_add_del_reply"
 746 }
 747 func (*IpfixClassifyTableAddDelReply) GetCrcString() string { return "e8d4e804" }
 748 func (*IpfixClassifyTableAddDelReply) GetMessageType() api.MessageType {
 749         return api.ReplyMessage
 750 }
 751
 752 func (m *IpfixClassifyTableAddDelReply) Size() (size int) {
 753         if m == nil {
 754                 return 0
 755         }
 756         size += 4 // m.Retval
 757         return size
 758 }
 759 func (m *IpfixClassifyTableAddDelReply) Marshal(b []byte) ([]byte, error) {
 760         if b == nil {
 761                 b = make([]byte, m.Size())
 762         }
 763         buf := codec.NewBuffer(b)
 764         buf.EncodeInt32(m.Retval)
 765         return buf.Bytes(), nil
 766 }
 767 func (m *IpfixClassifyTableAddDelReply) Unmarshal(b []byte) error {
 768         buf := codec.NewBuffer(b)
 769         m.Retval = buf.DecodeInt32()
 770         return nil
 771 }
 772
 773 // IpfixClassifyTableDetails defines message 'ipfix_classify_table_details'.
 774 type IpfixClassifyTableDetails struct {
 775         TableID           uint32        `binapi:"u32,name=table_id" json:"table_id,omitempty"`
 776         IPVersion         AddressFamily `binapi:"address_family,name=ip_version" json:"ip_version,omitempty"`
 777         TransportProtocol IPProto       `binapi:"ip_proto,name=transport_protocol" json:"transport_protocol,omitempty"`
 778 }
 779
 780 func (m *IpfixClassifyTableDetails) Reset()               { *m = IpfixClassifyTableDetails{} }
 781 func (*IpfixClassifyTableDetails) GetMessageName() string { return "ipfix_classify_table_details" }
 782 func (*IpfixClassifyTableDetails) GetCrcString() string   { return "7c8351ec" }
 783 func (*IpfixClassifyTableDetails) GetMessageType() api.MessageType {
 784         return api.ReplyMessage
 785 }
 786
 787 func (m *IpfixClassifyTableDetails) Size() (size int) {
 788         if m == nil {
 789                 return 0
 790         }
 791         size += 4 // m.TableID
 792         size += 4 // m.IPVersion
 793         size += 4 // m.TransportProtocol
 794         return size
 795 }
 796 func (m *IpfixClassifyTableDetails) Marshal(b []byte) ([]byte, error) {
 797         if b == nil {
 798                 b = make([]byte, m.Size())
 799         }
 800         buf := codec.NewBuffer(b)
 801         buf.EncodeUint32(m.TableID)
 802         buf.EncodeUint32(uint32(m.IPVersion))
 803         buf.EncodeUint32(uint32(m.TransportProtocol))
 804         return buf.Bytes(), nil
 805 }
 806 func (m *IpfixClassifyTableDetails) Unmarshal(b []byte) error {
 807         buf := codec.NewBuffer(b)
 808         m.TableID = buf.DecodeUint32()
 809         m.IPVersion = AddressFamily(buf.DecodeUint32())
 810         m.TransportProtocol = IPProto(buf.DecodeUint32())
 811         return nil
 812 }
 813
 814 // IpfixClassifyTableDump defines message 'ipfix_classify_table_dump'.
 815 type IpfixClassifyTableDump struct{}
 816
 817 func (m *IpfixClassifyTableDump) Reset()               { *m = IpfixClassifyTableDump{} }
 818 func (*IpfixClassifyTableDump) GetMessageName() string { return "ipfix_classify_table_dump" }
 819 func (*IpfixClassifyTableDump) GetCrcString() string   { return "51077d14" }
 820 func (*IpfixClassifyTableDump) GetMessageType() api.MessageType {
 821         return api.RequestMessage
 822 }
 823
 824 func (m *IpfixClassifyTableDump) Size() (size int) {
 825         if m == nil {
 826                 return 0
 827         }
 828         return size
 829 }
 830 func (m *IpfixClassifyTableDump) Marshal(b []byte) ([]byte, error) {
 831         if b == nil {
 832                 b = make([]byte, m.Size())
 833         }
 834         buf := codec.NewBuffer(b)
 835         return buf.Bytes(), nil
 836 }
 837 func (m *IpfixClassifyTableDump) Unmarshal(b []byte) error {
 838         return nil
 839 }
 840
 841 // IpfixExporterDetails defines message 'ipfix_exporter_details'.
 842 type IpfixExporterDetails struct {
 843         CollectorAddress Address `binapi:"address,name=collector_address" json:"collector_address,omitempty"`
 844         CollectorPort    uint16  `binapi:"u16,name=collector_port" json:"collector_port,omitempty"`
 845         SrcAddress       Address `binapi:"address,name=src_address" json:"src_address,omitempty"`
 846         VrfID            uint32  `binapi:"u32,name=vrf_id" json:"vrf_id,omitempty"`
 847         PathMtu          uint32  `binapi:"u32,name=path_mtu" json:"path_mtu,omitempty"`
 848         TemplateInterval uint32  `binapi:"u32,name=template_interval" json:"template_interval,omitempty"`
 849         UDPChecksum      bool    `binapi:"bool,name=udp_checksum" json:"udp_checksum,omitempty"`
 850 }
 851
 852 func (m *IpfixExporterDetails) Reset()               { *m = IpfixExporterDetails{} }
 853 func (*IpfixExporterDetails) GetMessageName() string { return "ipfix_exporter_details" }
 854 func (*IpfixExporterDetails) GetCrcString() string   { return "11e07413" }
 855 func (*IpfixExporterDetails) GetMessageType() api.MessageType {
 856         return api.ReplyMessage
 857 }
 858
 859 func (m *IpfixExporterDetails) Size() (size int) {
 860         if m == nil {
 861                 return 0
 862         }
 863         size += 4      // m.CollectorAddress.Af
 864         size += 1 * 16 // m.CollectorAddress.Un
 865         size += 2      // m.CollectorPort
 866         size += 4      // m.SrcAddress.Af
 867         size += 1 * 16 // m.SrcAddress.Un
 868         size += 4      // m.VrfID
 869         size += 4      // m.PathMtu
 870         size += 4      // m.TemplateInterval
 871         size += 1      // m.UDPChecksum
 872         return size
 873 }
 874 func (m *IpfixExporterDetails) Marshal(b []byte) ([]byte, error) {
 875         if b == nil {
 876                 b = make([]byte, m.Size())
 877         }
 878         buf := codec.NewBuffer(b)
 879         buf.EncodeUint32(uint32(m.CollectorAddress.Af))
 880         buf.EncodeBytes(m.CollectorAddress.Un.XXX_UnionData[:], 16)
 881         buf.EncodeUint16(m.CollectorPort)
 882         buf.EncodeUint32(uint32(m.SrcAddress.Af))
 883         buf.EncodeBytes(m.SrcAddress.Un.XXX_UnionData[:], 16)
 884         buf.EncodeUint32(m.VrfID)
 885         buf.EncodeUint32(m.PathMtu)
 886         buf.EncodeUint32(m.TemplateInterval)
 887         buf.EncodeBool(m.UDPChecksum)
 888         return buf.Bytes(), nil
 889 }
 890 func (m *IpfixExporterDetails) Unmarshal(b []byte) error {
 891         buf := codec.NewBuffer(b)
 892         m.CollectorAddress.Af = AddressFamily(buf.DecodeUint32())
 893         copy(m.CollectorAddress.Un.XXX_UnionData[:], buf.DecodeBytes(16))
 894         m.CollectorPort = buf.DecodeUint16()
 895         m.SrcAddress.Af = AddressFamily(buf.DecodeUint32())
 896         copy(m.SrcAddress.Un.XXX_UnionData[:], buf.DecodeBytes(16))
 897         m.VrfID = buf.DecodeUint32()
 898         m.PathMtu = buf.DecodeUint32()
 899         m.TemplateInterval = buf.DecodeUint32()
 900         m.UDPChecksum = buf.DecodeBool()
 901         return nil
 902 }
 903
 904 // IpfixExporterDump defines message 'ipfix_exporter_dump'.
 905 type IpfixExporterDump struct{}
 906
 907 func (m *IpfixExporterDump) Reset()               { *m = IpfixExporterDump{} }
 908 func (*IpfixExporterDump) GetMessageName() string { return "ipfix_exporter_dump" }
 909 func (*IpfixExporterDump) GetCrcString() string   { return "51077d14" }
 910 func (*IpfixExporterDump) GetMessageType() api.MessageType {
 911         return api.RequestMessage
 912 }
 913
 914 func (m *IpfixExporterDump) Size() (size int) {
 915         if m == nil {
 916                 return 0
 917         }
 918         return size
 919 }
 920 func (m *IpfixExporterDump) Marshal(b []byte) ([]byte, error) {
 921         if b == nil {
 922                 b = make([]byte, m.Size())
 923         }
 924         buf := codec.NewBuffer(b)
 925         return buf.Bytes(), nil
 926 }
 927 func (m *IpfixExporterDump) Unmarshal(b []byte) error {
 928         return nil
 929 }
 930
 931 // IpfixFlush defines message 'ipfix_flush'.
 932 type IpfixFlush struct{}
 933
 934 func (m *IpfixFlush) Reset()               { *m = IpfixFlush{} }
 935 func (*IpfixFlush) GetMessageName() string { return "ipfix_flush" }
 936 func (*IpfixFlush) GetCrcString() string   { return "51077d14" }
 937 func (*IpfixFlush) GetMessageType() api.MessageType {
 938         return api.RequestMessage
 939 }
 940
 941 func (m *IpfixFlush) Size() (size int) {
 942         if m == nil {
 943                 return 0
 944         }
 945         return size
 946 }
 947 func (m *IpfixFlush) Marshal(b []byte) ([]byte, error) {
 948         if b == nil {
 949                 b = make([]byte, m.Size())
 950         }
 951         buf := codec.NewBuffer(b)
 952         return buf.Bytes(), nil
 953 }
 954 func (m *IpfixFlush) Unmarshal(b []byte) error {
 955         return nil
 956 }
 957
 958 // IpfixFlushReply defines message 'ipfix_flush_reply'.
 959 type IpfixFlushReply struct {
 960         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
 961 }
 962
 963 func (m *IpfixFlushReply) Reset()               { *m = IpfixFlushReply{} }
 964 func (*IpfixFlushReply) GetMessageName() string { return "ipfix_flush_reply" }
 965 func (*IpfixFlushReply) GetCrcString() string   { return "e8d4e804" }
 966 func (*IpfixFlushReply) GetMessageType() api.MessageType {
 967         return api.ReplyMessage
 968 }
 969
 970 func (m *IpfixFlushReply) Size() (size int) {
 971         if m == nil {
 972                 return 0
 973         }
 974         size += 4 // m.Retval
 975         return size
 976 }
 977 func (m *IpfixFlushReply) Marshal(b []byte) ([]byte, error) {
 978         if b == nil {
 979                 b = make([]byte, m.Size())
 980         }
 981         buf := codec.NewBuffer(b)
 982         buf.EncodeInt32(m.Retval)
 983         return buf.Bytes(), nil
 984 }
 985 func (m *IpfixFlushReply) Unmarshal(b []byte) error {
 986         buf := codec.NewBuffer(b)
 987         m.Retval = buf.DecodeInt32()
 988         return nil
 989 }
 990
 991 // SetIpfixClassifyStream defines message 'set_ipfix_classify_stream'.
 992 type SetIpfixClassifyStream struct {
 993         DomainID uint32 `binapi:"u32,name=domain_id" json:"domain_id,omitempty"`
 994         SrcPort  uint16 `binapi:"u16,name=src_port" json:"src_port,omitempty"`
 995 }
 996
 997 func (m *SetIpfixClassifyStream) Reset()               { *m = SetIpfixClassifyStream{} }
 998 func (*SetIpfixClassifyStream) GetMessageName() string { return "set_ipfix_classify_stream" }
 999 func (*SetIpfixClassifyStream) GetCrcString() string   { return "c9cbe053" }
1000 func (*SetIpfixClassifyStream) GetMessageType() api.MessageType {
1001         return api.RequestMessage
1002 }
1003
1004 func (m *SetIpfixClassifyStream) Size() (size int) {
1005         if m == nil {
1006                 return 0
1007         }
1008         size += 4 // m.DomainID
1009         size += 2 // m.SrcPort
1010         return size
1011 }
1012 func (m *SetIpfixClassifyStream) Marshal(b []byte) ([]byte, error) {
1013         if b == nil {
1014                 b = make([]byte, m.Size())
1015         }
1016         buf := codec.NewBuffer(b)
1017         buf.EncodeUint32(m.DomainID)
1018         buf.EncodeUint16(m.SrcPort)
1019         return buf.Bytes(), nil
1020 }
1021 func (m *SetIpfixClassifyStream) Unmarshal(b []byte) error {
1022         buf := codec.NewBuffer(b)
1023         m.DomainID = buf.DecodeUint32()
1024         m.SrcPort = buf.DecodeUint16()
1025         return nil
1026 }
1027
1028 // SetIpfixClassifyStreamReply defines message 'set_ipfix_classify_stream_reply'.
1029 type SetIpfixClassifyStreamReply struct {
1030         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
1031 }
1032
1033 func (m *SetIpfixClassifyStreamReply) Reset()               { *m = SetIpfixClassifyStreamReply{} }
1034 func (*SetIpfixClassifyStreamReply) GetMessageName() string { return "set_ipfix_classify_stream_reply" }
1035 func (*SetIpfixClassifyStreamReply) GetCrcString() string   { return "e8d4e804" }
1036 func (*SetIpfixClassifyStreamReply) GetMessageType() api.MessageType {
1037         return api.ReplyMessage
1038 }
1039
1040 func (m *SetIpfixClassifyStreamReply) Size() (size int) {
1041         if m == nil {
1042                 return 0
1043         }
1044         size += 4 // m.Retval
1045         return size
1046 }
1047 func (m *SetIpfixClassifyStreamReply) Marshal(b []byte) ([]byte, error) {
1048         if b == nil {
1049                 b = make([]byte, m.Size())
1050         }
1051         buf := codec.NewBuffer(b)
1052         buf.EncodeInt32(m.Retval)
1053         return buf.Bytes(), nil
1054 }
1055 func (m *SetIpfixClassifyStreamReply) Unmarshal(b []byte) error {
1056         buf := codec.NewBuffer(b)
1057         m.Retval = buf.DecodeInt32()
1058         return nil
1059 }
1060
1061 // SetIpfixExporter defines message 'set_ipfix_exporter'.
1062 type SetIpfixExporter struct {
1063         CollectorAddress Address `binapi:"address,name=collector_address" json:"collector_address,omitempty"`
1064         CollectorPort    uint16  `binapi:"u16,name=collector_port" json:"collector_port,omitempty"`
1065         SrcAddress       Address `binapi:"address,name=src_address" json:"src_address,omitempty"`
1066         VrfID            uint32  `binapi:"u32,name=vrf_id" json:"vrf_id,omitempty"`
1067         PathMtu          uint32  `binapi:"u32,name=path_mtu" json:"path_mtu,omitempty"`
1068         TemplateInterval uint32  `binapi:"u32,name=template_interval" json:"template_interval,omitempty"`
1069         UDPChecksum      bool    `binapi:"bool,name=udp_checksum" json:"udp_checksum,omitempty"`
1070 }
1071
1072 func (m *SetIpfixExporter) Reset()               { *m = SetIpfixExporter{} }
1073 func (*SetIpfixExporter) GetMessageName() string { return "set_ipfix_exporter" }
1074 func (*SetIpfixExporter) GetCrcString() string   { return "69284e07" }
1075 func (*SetIpfixExporter) GetMessageType() api.MessageType {
1076         return api.RequestMessage
1077 }
1078
1079 func (m *SetIpfixExporter) Size() (size int) {
1080         if m == nil {
1081                 return 0
1082         }
1083         size += 4      // m.CollectorAddress.Af
1084         size += 1 * 16 // m.CollectorAddress.Un
1085         size += 2      // m.CollectorPort
1086         size += 4      // m.SrcAddress.Af
1087         size += 1 * 16 // m.SrcAddress.Un
1088         size += 4      // m.VrfID
1089         size += 4      // m.PathMtu
1090         size += 4      // m.TemplateInterval
1091         size += 1      // m.UDPChecksum
1092         return size
1093 }
1094 func (m *SetIpfixExporter) Marshal(b []byte) ([]byte, error) {
1095         if b == nil {
1096                 b = make([]byte, m.Size())
1097         }
1098         buf := codec.NewBuffer(b)
1099         buf.EncodeUint32(uint32(m.CollectorAddress.Af))
1100         buf.EncodeBytes(m.CollectorAddress.Un.XXX_UnionData[:], 16)
1101         buf.EncodeUint16(m.CollectorPort)
1102         buf.EncodeUint32(uint32(m.SrcAddress.Af))
1103         buf.EncodeBytes(m.SrcAddress.Un.XXX_UnionData[:], 16)
1104         buf.EncodeUint32(m.VrfID)
1105         buf.EncodeUint32(m.PathMtu)
1106         buf.EncodeUint32(m.TemplateInterval)
1107         buf.EncodeBool(m.UDPChecksum)
1108         return buf.Bytes(), nil
1109 }
1110 func (m *SetIpfixExporter) Unmarshal(b []byte) error {
1111         buf := codec.NewBuffer(b)
1112         m.CollectorAddress.Af = AddressFamily(buf.DecodeUint32())
1113         copy(m.CollectorAddress.Un.XXX_UnionData[:], buf.DecodeBytes(16))
1114         m.CollectorPort = buf.DecodeUint16()
1115         m.SrcAddress.Af = AddressFamily(buf.DecodeUint32())
1116         copy(m.SrcAddress.Un.XXX_UnionData[:], buf.DecodeBytes(16))
1117         m.VrfID = buf.DecodeUint32()
1118         m.PathMtu = buf.DecodeUint32()
1119         m.TemplateInterval = buf.DecodeUint32()
1120         m.UDPChecksum = buf.DecodeBool()
1121         return nil
1122 }
1123
1124 // SetIpfixExporterReply defines message 'set_ipfix_exporter_reply'.
1125 type SetIpfixExporterReply struct {
1126         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
1127 }
1128
1129 func (m *SetIpfixExporterReply) Reset()               { *m = SetIpfixExporterReply{} }
1130 func (*SetIpfixExporterReply) GetMessageName() string { return "set_ipfix_exporter_reply" }
1131 func (*SetIpfixExporterReply) GetCrcString() string   { return "e8d4e804" }
1132 func (*SetIpfixExporterReply) GetMessageType() api.MessageType {
1133         return api.ReplyMessage
1134 }
1135
1136 func (m *SetIpfixExporterReply) Size() (size int) {
1137         if m == nil {
1138                 return 0
1139         }
1140         size += 4 // m.Retval
1141         return size
1142 }
1143 func (m *SetIpfixExporterReply) Marshal(b []byte) ([]byte, error) {
1144         if b == nil {
1145                 b = make([]byte, m.Size())
1146         }
1147         buf := codec.NewBuffer(b)
1148         buf.EncodeInt32(m.Retval)
1149         return buf.Bytes(), nil
1150 }
1151 func (m *SetIpfixExporterReply) Unmarshal(b []byte) error {
1152         buf := codec.NewBuffer(b)
1153         m.Retval = buf.DecodeInt32()
1154         return nil
1155 }
1156
1157 func init() { file_ipfix_export_binapi_init() }
1158 func file_ipfix_export_binapi_init() {
1159         api.RegisterMessage((*IpfixClassifyStreamDetails)(nil), "ipfix_classify_stream_details_2903539d")
1160         api.RegisterMessage((*IpfixClassifyStreamDump)(nil), "ipfix_classify_stream_dump_51077d14")
1161         api.RegisterMessage((*IpfixClassifyTableAddDel)(nil), "ipfix_classify_table_add_del_5118bc5e")
1162         api.RegisterMessage((*IpfixClassifyTableAddDelReply)(nil), "ipfix_classify_table_add_del_reply_e8d4e804")
1163         api.RegisterMessage((*IpfixClassifyTableDetails)(nil), "ipfix_classify_table_details_7c8351ec")
1164         api.RegisterMessage((*IpfixClassifyTableDump)(nil), "ipfix_classify_table_dump_51077d14")
1165         api.RegisterMessage((*IpfixExporterDetails)(nil), "ipfix_exporter_details_11e07413")
1166         api.RegisterMessage((*IpfixExporterDump)(nil), "ipfix_exporter_dump_51077d14")
1167         api.RegisterMessage((*IpfixFlush)(nil), "ipfix_flush_51077d14")
1168         api.RegisterMessage((*IpfixFlushReply)(nil), "ipfix_flush_reply_e8d4e804")
1169         api.RegisterMessage((*SetIpfixClassifyStream)(nil), "set_ipfix_classify_stream_c9cbe053")
1170         api.RegisterMessage((*SetIpfixClassifyStreamReply)(nil), "set_ipfix_classify_stream_reply_e8d4e804")
1171         api.RegisterMessage((*SetIpfixExporter)(nil), "set_ipfix_exporter_69284e07")
1172         api.RegisterMessage((*SetIpfixExporterReply)(nil), "set_ipfix_exporter_reply_e8d4e804")
1173 }
1174
1175 // Messages returns list of all messages in this module.
1176 func AllMessages() []api.Message {
1177         return []api.Message{
1178                 (*IpfixClassifyStreamDetails)(nil),
1179                 (*IpfixClassifyStreamDump)(nil),
1180                 (*IpfixClassifyTableAddDel)(nil),
1181                 (*IpfixClassifyTableAddDelReply)(nil),
1182                 (*IpfixClassifyTableDetails)(nil),
1183                 (*IpfixClassifyTableDump)(nil),
1184                 (*IpfixExporterDetails)(nil),
1185                 (*IpfixExporterDump)(nil),
1186                 (*IpfixFlush)(nil),
1187                 (*IpfixFlushReply)(nil),
1188                 (*SetIpfixClassifyStream)(nil),
1189                 (*SetIpfixClassifyStreamReply)(nil),
1190                 (*SetIpfixExporter)(nil),
1191                 (*SetIpfixExporterReply)(nil),
1192         }
1193 }