examples/bin_api/maps/maps.ba.go

   1 // Code generated by GoVPP binapi-generator. DO NOT EDIT.
   2 //  source: map.api.json
   3
   4 /*
   5  Package maps is a generated from VPP binary API module 'map'.
   6
   7  It contains following objects:
   8          16 services
   9           1 enum
  10           2 aliases
  11           5 types
  12           1 union
  13          32 messages
  14 */
  15 package maps
  16
  17 import api "git.fd.io/govpp.git/api"
  18 import struc "github.com/lunixbochs/struc"
  19 import bytes "bytes"
  20
  21 // Reference imports to suppress errors if they are not otherwise used.
  22 var _ = api.RegisterMessage
  23 var _ = struc.Pack
  24 var _ = bytes.NewBuffer
  25
  26 // Services represents VPP binary API services:
  27 type Services interface {
  28         DumpMapDomain(*MapDomainDump) ([]*MapDomainDetails, error)
  29         DumpMapRule(*MapRuleDump) ([]*MapRuleDetails, error)
  30         MapAddDelRule(*MapAddDelRule) (*MapAddDelRuleReply, error)
  31         MapAddDomain(*MapAddDomain) (*MapAddDomainReply, error)
  32         MapDelDomain(*MapDelDomain) (*MapDelDomainReply, error)
  33         MapIfEnableDisable(*MapIfEnableDisable) (*MapIfEnableDisableReply, error)
  34         MapParamAddDelPreResolve(*MapParamAddDelPreResolve) (*MapParamAddDelPreResolveReply, error)
  35         MapParamGet(*MapParamGet) (*MapParamGetReply, error)
  36         MapParamSetFragmentation(*MapParamSetFragmentation) (*MapParamSetFragmentationReply, error)
  37         MapParamSetICMP(*MapParamSetICMP) (*MapParamSetICMPReply, error)
  38         MapParamSetICMP6(*MapParamSetICMP6) (*MapParamSetICMP6Reply, error)
  39         MapParamSetReassembly(*MapParamSetReassembly) (*MapParamSetReassemblyReply, error)
  40         MapParamSetSecurityCheck(*MapParamSetSecurityCheck) (*MapParamSetSecurityCheckReply, error)
  41         MapParamSetTCP(*MapParamSetTCP) (*MapParamSetTCPReply, error)
  42         MapParamSetTrafficClass(*MapParamSetTrafficClass) (*MapParamSetTrafficClassReply, error)
  43         MapSummaryStats(*MapSummaryStats) (*MapSummaryStatsReply, error)
  44 }
  45
  46 /* Enums */
  47
  48 // AddressFamily represents VPP binary API enum 'address_family':
  49 type AddressFamily uint32
  50
  51 const (
  52         ADDRESS_IP4 AddressFamily = 0
  53         ADDRESS_IP6 AddressFamily = 1
  54 )
  55
  56 /* Aliases */
  57
  58 // IP4Address represents VPP binary API alias 'ip4_address':
  59 type IP4Address [4]uint8
  60
  61 // IP6Address represents VPP binary API alias 'ip6_address':
  62 type IP6Address [16]uint8
  63
  64 /* Types */
  65
  66 // Address represents VPP binary API type 'address':
  67 type Address struct {
  68         Af AddressFamily
  69         Un AddressUnion
  70 }
  71
  72 func (*Address) GetTypeName() string {
  73         return "address"
  74 }
  75 func (*Address) GetCrcString() string {
  76         return "09f11671"
  77 }
  78
  79 // IP4Prefix represents VPP binary API type 'ip4_prefix':
  80 type IP4Prefix struct {
  81         Prefix IP4Address
  82         Len    uint8
  83 }
  84
  85 func (*IP4Prefix) GetTypeName() string {
  86         return "ip4_prefix"
  87 }
  88 func (*IP4Prefix) GetCrcString() string {
  89         return "ea8dc11d"
  90 }
  91
  92 // IP6Prefix represents VPP binary API type 'ip6_prefix':
  93 type IP6Prefix struct {
  94         Prefix IP6Address
  95         Len    uint8
  96 }
  97
  98 func (*IP6Prefix) GetTypeName() string {
  99         return "ip6_prefix"
 100 }
 101 func (*IP6Prefix) GetCrcString() string {
 102         return "779fd64f"
 103 }
 104
 105 // Mprefix represents VPP binary API type 'mprefix':
 106 type Mprefix struct {
 107         Af               AddressFamily
 108         GrpAddressLength uint16
 109         GrpAddress       AddressUnion
 110         SrcAddress       AddressUnion
 111 }
 112
 113 func (*Mprefix) GetTypeName() string {
 114         return "mprefix"
 115 }
 116 func (*Mprefix) GetCrcString() string {
 117         return "1c4cba05"
 118 }
 119
 120 // Prefix represents VPP binary API type 'prefix':
 121 type Prefix struct {
 122         Address       Address
 123         AddressLength uint8
 124 }
 125
 126 func (*Prefix) GetTypeName() string {
 127         return "prefix"
 128 }
 129 func (*Prefix) GetCrcString() string {
 130         return "0403aebc"
 131 }
 132
 133 /* Unions */
 134
 135 // AddressUnion represents VPP binary API union 'address_union':
 136 type AddressUnion struct {
 137         Union_data [16]byte
 138 }
 139
 140 func (*AddressUnion) GetTypeName() string {
 141         return "address_union"
 142 }
 143 func (*AddressUnion) GetCrcString() string {
 144         return "d68a2fb4"
 145 }
 146
 147 func AddressUnionIP4(a IP4Address) (u AddressUnion) {
 148         u.SetIP4(a)
 149         return
 150 }
 151 func (u *AddressUnion) SetIP4(a IP4Address) {
 152         var b = new(bytes.Buffer)
 153         if err := struc.Pack(b, &a); err != nil {
 154                 return
 155         }
 156         copy(u.Union_data[:], b.Bytes())
 157 }
 158 func (u *AddressUnion) GetIP4() (a IP4Address) {
 159         var b = bytes.NewReader(u.Union_data[:])
 160         struc.Unpack(b, &a)
 161         return
 162 }
 163
 164 func AddressUnionIP6(a IP6Address) (u AddressUnion) {
 165         u.SetIP6(a)
 166         return
 167 }
 168 func (u *AddressUnion) SetIP6(a IP6Address) {
 169         var b = new(bytes.Buffer)
 170         if err := struc.Pack(b, &a); err != nil {
 171                 return
 172         }
 173         copy(u.Union_data[:], b.Bytes())
 174 }
 175 func (u *AddressUnion) GetIP6() (a IP6Address) {
 176         var b = bytes.NewReader(u.Union_data[:])
 177         struc.Unpack(b, &a)
 178         return
 179 }
 180
 181 /* Messages */
 182
 183 // MapAddDelRule represents VPP binary API message 'map_add_del_rule':
 184 type MapAddDelRule struct {
 185         Index  uint32
 186         IsAdd  bool
 187         IP6Dst IP6Address
 188         Psid   uint16
 189 }
 190
 191 func (*MapAddDelRule) GetMessageName() string {
 192         return "map_add_del_rule"
 193 }
 194 func (*MapAddDelRule) GetCrcString() string {
 195         return "e6132040"
 196 }
 197 func (*MapAddDelRule) GetMessageType() api.MessageType {
 198         return api.RequestMessage
 199 }
 200
 201 // MapAddDelRuleReply represents VPP binary API message 'map_add_del_rule_reply':
 202 type MapAddDelRuleReply struct {
 203         Retval int32
 204 }
 205
 206 func (*MapAddDelRuleReply) GetMessageName() string {
 207         return "map_add_del_rule_reply"
 208 }
 209 func (*MapAddDelRuleReply) GetCrcString() string {
 210         return "e8d4e804"
 211 }
 212 func (*MapAddDelRuleReply) GetMessageType() api.MessageType {
 213         return api.ReplyMessage
 214 }
 215
 216 // MapAddDomain represents VPP binary API message 'map_add_domain':
 217 type MapAddDomain struct {
 218         IP6Prefix  IP6Prefix
 219         IP4Prefix  IP4Prefix
 220         IP6Src     IP6Prefix
 221         EaBitsLen  uint8
 222         PsidOffset uint8
 223         PsidLength uint8
 224         Mtu        uint16
 225 }
 226
 227 func (*MapAddDomain) GetMessageName() string {
 228         return "map_add_domain"
 229 }
 230 func (*MapAddDomain) GetCrcString() string {
 231         return "a9358068"
 232 }
 233 func (*MapAddDomain) GetMessageType() api.MessageType {
 234         return api.RequestMessage
 235 }
 236
 237 // MapAddDomainReply represents VPP binary API message 'map_add_domain_reply':
 238 type MapAddDomainReply struct {
 239         Index  uint32
 240         Retval int32
 241 }
 242
 243 func (*MapAddDomainReply) GetMessageName() string {
 244         return "map_add_domain_reply"
 245 }
 246 func (*MapAddDomainReply) GetCrcString() string {
 247         return "3e6d4e2c"
 248 }
 249 func (*MapAddDomainReply) GetMessageType() api.MessageType {
 250         return api.ReplyMessage
 251 }
 252
 253 // MapDelDomain represents VPP binary API message 'map_del_domain':
 254 type MapDelDomain struct {
 255         Index uint32
 256 }
 257
 258 func (*MapDelDomain) GetMessageName() string {
 259         return "map_del_domain"
 260 }
 261 func (*MapDelDomain) GetCrcString() string {
 262         return "8ac76db6"
 263 }
 264 func (*MapDelDomain) GetMessageType() api.MessageType {
 265         return api.RequestMessage
 266 }
 267
 268 // MapDelDomainReply represents VPP binary API message 'map_del_domain_reply':
 269 type MapDelDomainReply struct {
 270         Retval int32
 271 }
 272
 273 func (*MapDelDomainReply) GetMessageName() string {
 274         return "map_del_domain_reply"
 275 }
 276 func (*MapDelDomainReply) GetCrcString() string {
 277         return "e8d4e804"
 278 }
 279 func (*MapDelDomainReply) GetMessageType() api.MessageType {
 280         return api.ReplyMessage
 281 }
 282
 283 // MapDomainDetails represents VPP binary API message 'map_domain_details':
 284 type MapDomainDetails struct {
 285         DomainIndex uint32
 286         IP6Prefix   IP6Prefix
 287         IP4Prefix   IP4Prefix
 288         IP6Src      IP6Prefix
 289         EaBitsLen   uint8
 290         PsidOffset  uint8
 291         PsidLength  uint8
 292         Flags       uint8
 293         Mtu         uint16
 294 }
 295
 296 func (*MapDomainDetails) GetMessageName() string {
 297         return "map_domain_details"
 298 }
 299 func (*MapDomainDetails) GetCrcString() string {
 300         return "2a17dcb8"
 301 }
 302 func (*MapDomainDetails) GetMessageType() api.MessageType {
 303         return api.ReplyMessage
 304 }
 305
 306 // MapDomainDump represents VPP binary API message 'map_domain_dump':
 307 type MapDomainDump struct{}
 308
 309 func (*MapDomainDump) GetMessageName() string {
 310         return "map_domain_dump"
 311 }
 312 func (*MapDomainDump) GetCrcString() string {
 313         return "51077d14"
 314 }
 315 func (*MapDomainDump) GetMessageType() api.MessageType {
 316         return api.RequestMessage
 317 }
 318
 319 // MapIfEnableDisable represents VPP binary API message 'map_if_enable_disable':
 320 type MapIfEnableDisable struct {
 321         SwIfIndex     uint32
 322         IsEnable      bool
 323         IsTranslation bool
 324 }
 325
 326 func (*MapIfEnableDisable) GetMessageName() string {
 327         return "map_if_enable_disable"
 328 }
 329 func (*MapIfEnableDisable) GetCrcString() string {
 330         return "61a30cd9"
 331 }
 332 func (*MapIfEnableDisable) GetMessageType() api.MessageType {
 333         return api.RequestMessage
 334 }
 335
 336 // MapIfEnableDisableReply represents VPP binary API message 'map_if_enable_disable_reply':
 337 type MapIfEnableDisableReply struct {
 338         Retval int32
 339 }
 340
 341 func (*MapIfEnableDisableReply) GetMessageName() string {
 342         return "map_if_enable_disable_reply"
 343 }
 344 func (*MapIfEnableDisableReply) GetCrcString() string {
 345         return "e8d4e804"
 346 }
 347 func (*MapIfEnableDisableReply) GetMessageType() api.MessageType {
 348         return api.ReplyMessage
 349 }
 350
 351 // MapParamAddDelPreResolve represents VPP binary API message 'map_param_add_del_pre_resolve':
 352 type MapParamAddDelPreResolve struct {
 353         IsAdd        bool
 354         IP4NhAddress IP4Address
 355         IP6NhAddress IP6Address
 356 }
 357
 358 func (*MapParamAddDelPreResolve) GetMessageName() string {
 359         return "map_param_add_del_pre_resolve"
 360 }
 361 func (*MapParamAddDelPreResolve) GetCrcString() string {
 362         return "ea9a9a4a"
 363 }
 364 func (*MapParamAddDelPreResolve) GetMessageType() api.MessageType {
 365         return api.RequestMessage
 366 }
 367
 368 // MapParamAddDelPreResolveReply represents VPP binary API message 'map_param_add_del_pre_resolve_reply':
 369 type MapParamAddDelPreResolveReply struct {
 370         Retval int32
 371 }
 372
 373 func (*MapParamAddDelPreResolveReply) GetMessageName() string {
 374         return "map_param_add_del_pre_resolve_reply"
 375 }
 376 func (*MapParamAddDelPreResolveReply) GetCrcString() string {
 377         return "e8d4e804"
 378 }
 379 func (*MapParamAddDelPreResolveReply) GetMessageType() api.MessageType {
 380         return api.ReplyMessage
 381 }
 382
 383 // MapParamGet represents VPP binary API message 'map_param_get':
 384 type MapParamGet struct{}
 385
 386 func (*MapParamGet) GetMessageName() string {
 387         return "map_param_get"
 388 }
 389 func (*MapParamGet) GetCrcString() string {
 390         return "51077d14"
 391 }
 392 func (*MapParamGet) GetMessageType() api.MessageType {
 393         return api.RequestMessage
 394 }
 395
 396 // MapParamGetReply represents VPP binary API message 'map_param_get_reply':
 397 type MapParamGetReply struct {
 398         Retval                 int32
 399         FragInner              uint8
 400         FragIgnoreDf           uint8
 401         ICMPIP4ErrRelaySrc     IP4Address
 402         ICMP6EnableUnreachable bool
 403         IP4NhAddress           IP4Address
 404         IP6NhAddress           IP6Address
 405         IP4LifetimeMs          uint16
 406         IP4PoolSize            uint16
 407         IP4Buffers             uint32
 408         IP4HtRatio             float64
 409         IP6LifetimeMs          uint16
 410         IP6PoolSize            uint16
 411         IP6Buffers             uint32
 412         IP6HtRatio             float64
 413         SecCheckEnable         bool
 414         SecCheckFragments      bool
 415         TcCopy                 bool
 416         TcClass                uint8
 417 }
 418
 419 func (*MapParamGetReply) GetMessageName() string {
 420         return "map_param_get_reply"
 421 }
 422 func (*MapParamGetReply) GetCrcString() string {
 423         return "b40e9226"
 424 }
 425 func (*MapParamGetReply) GetMessageType() api.MessageType {
 426         return api.ReplyMessage
 427 }
 428
 429 // MapParamSetFragmentation represents VPP binary API message 'map_param_set_fragmentation':
 430 type MapParamSetFragmentation struct {
 431         Inner    bool
 432         IgnoreDf bool
 433 }
 434
 435 func (*MapParamSetFragmentation) GetMessageName() string {
 436         return "map_param_set_fragmentation"
 437 }
 438 func (*MapParamSetFragmentation) GetCrcString() string {
 439         return "9ff54d90"
 440 }
 441 func (*MapParamSetFragmentation) GetMessageType() api.MessageType {
 442         return api.RequestMessage
 443 }
 444
 445 // MapParamSetFragmentationReply represents VPP binary API message 'map_param_set_fragmentation_reply':
 446 type MapParamSetFragmentationReply struct {
 447         Retval int32
 448 }
 449
 450 func (*MapParamSetFragmentationReply) GetMessageName() string {
 451         return "map_param_set_fragmentation_reply"
 452 }
 453 func (*MapParamSetFragmentationReply) GetCrcString() string {
 454         return "e8d4e804"
 455 }
 456 func (*MapParamSetFragmentationReply) GetMessageType() api.MessageType {
 457         return api.ReplyMessage
 458 }
 459
 460 // MapParamSetICMP represents VPP binary API message 'map_param_set_icmp':
 461 type MapParamSetICMP struct {
 462         IP4ErrRelaySrc IP4Address
 463 }
 464
 465 func (*MapParamSetICMP) GetMessageName() string {
 466         return "map_param_set_icmp"
 467 }
 468 func (*MapParamSetICMP) GetCrcString() string {
 469         return "4c0a4fd2"
 470 }
 471 func (*MapParamSetICMP) GetMessageType() api.MessageType {
 472         return api.RequestMessage
 473 }
 474
 475 // MapParamSetICMP6 represents VPP binary API message 'map_param_set_icmp6':
 476 type MapParamSetICMP6 struct {
 477         EnableUnreachable bool
 478 }
 479
 480 func (*MapParamSetICMP6) GetMessageName() string {
 481         return "map_param_set_icmp6"
 482 }
 483 func (*MapParamSetICMP6) GetCrcString() string {
 484         return "5d01f8c1"
 485 }
 486 func (*MapParamSetICMP6) GetMessageType() api.MessageType {
 487         return api.RequestMessage
 488 }
 489
 490 // MapParamSetICMP6Reply represents VPP binary API message 'map_param_set_icmp6_reply':
 491 type MapParamSetICMP6Reply struct {
 492         Retval int32
 493 }
 494
 495 func (*MapParamSetICMP6Reply) GetMessageName() string {
 496         return "map_param_set_icmp6_reply"
 497 }
 498 func (*MapParamSetICMP6Reply) GetCrcString() string {
 499         return "e8d4e804"
 500 }
 501 func (*MapParamSetICMP6Reply) GetMessageType() api.MessageType {
 502         return api.ReplyMessage
 503 }
 504
 505 // MapParamSetICMPReply represents VPP binary API message 'map_param_set_icmp_reply':
 506 type MapParamSetICMPReply struct {
 507         Retval int32
 508 }
 509
 510 func (*MapParamSetICMPReply) GetMessageName() string {
 511         return "map_param_set_icmp_reply"
 512 }
 513 func (*MapParamSetICMPReply) GetCrcString() string {
 514         return "e8d4e804"
 515 }
 516 func (*MapParamSetICMPReply) GetMessageType() api.MessageType {
 517         return api.ReplyMessage
 518 }
 519
 520 // MapParamSetReassembly represents VPP binary API message 'map_param_set_reassembly':
 521 type MapParamSetReassembly struct {
 522         IsIP6      bool
 523         LifetimeMs uint16
 524         PoolSize   uint16
 525         Buffers    uint32
 526         HtRatio    float64
 527 }
 528
 529 func (*MapParamSetReassembly) GetMessageName() string {
 530         return "map_param_set_reassembly"
 531 }
 532 func (*MapParamSetReassembly) GetCrcString() string {
 533         return "54172b10"
 534 }
 535 func (*MapParamSetReassembly) GetMessageType() api.MessageType {
 536         return api.RequestMessage
 537 }
 538
 539 // MapParamSetReassemblyReply represents VPP binary API message 'map_param_set_reassembly_reply':
 540 type MapParamSetReassemblyReply struct {
 541         Retval int32
 542 }
 543
 544 func (*MapParamSetReassemblyReply) GetMessageName() string {
 545         return "map_param_set_reassembly_reply"
 546 }
 547 func (*MapParamSetReassemblyReply) GetCrcString() string {
 548         return "e8d4e804"
 549 }
 550 func (*MapParamSetReassemblyReply) GetMessageType() api.MessageType {
 551         return api.ReplyMessage
 552 }
 553
 554 // MapParamSetSecurityCheck represents VPP binary API message 'map_param_set_security_check':
 555 type MapParamSetSecurityCheck struct {
 556         Enable    bool
 557         Fragments bool
 558 }
 559
 560 func (*MapParamSetSecurityCheck) GetMessageName() string {
 561         return "map_param_set_security_check"
 562 }
 563 func (*MapParamSetSecurityCheck) GetCrcString() string {
 564         return "6abe9836"
 565 }
 566 func (*MapParamSetSecurityCheck) GetMessageType() api.MessageType {
 567         return api.RequestMessage
 568 }
 569
 570 // MapParamSetSecurityCheckReply represents VPP binary API message 'map_param_set_security_check_reply':
 571 type MapParamSetSecurityCheckReply struct {
 572         Retval int32
 573 }
 574
 575 func (*MapParamSetSecurityCheckReply) GetMessageName() string {
 576         return "map_param_set_security_check_reply"
 577 }
 578 func (*MapParamSetSecurityCheckReply) GetCrcString() string {
 579         return "e8d4e804"
 580 }
 581 func (*MapParamSetSecurityCheckReply) GetMessageType() api.MessageType {
 582         return api.ReplyMessage
 583 }
 584
 585 // MapParamSetTCP represents VPP binary API message 'map_param_set_tcp':
 586 type MapParamSetTCP struct {
 587         TCPMss uint16
 588 }
 589
 590 func (*MapParamSetTCP) GetMessageName() string {
 591         return "map_param_set_tcp"
 592 }
 593 func (*MapParamSetTCP) GetCrcString() string {
 594         return "87a825d9"
 595 }
 596 func (*MapParamSetTCP) GetMessageType() api.MessageType {
 597         return api.RequestMessage
 598 }
 599
 600 // MapParamSetTCPReply represents VPP binary API message 'map_param_set_tcp_reply':
 601 type MapParamSetTCPReply struct {
 602         Retval int32
 603 }
 604
 605 func (*MapParamSetTCPReply) GetMessageName() string {
 606         return "map_param_set_tcp_reply"
 607 }
 608 func (*MapParamSetTCPReply) GetCrcString() string {
 609         return "e8d4e804"
 610 }
 611 func (*MapParamSetTCPReply) GetMessageType() api.MessageType {
 612         return api.ReplyMessage
 613 }
 614
 615 // MapParamSetTrafficClass represents VPP binary API message 'map_param_set_traffic_class':
 616 type MapParamSetTrafficClass struct {
 617         Copy  bool
 618         Class uint8
 619 }
 620
 621 func (*MapParamSetTrafficClass) GetMessageName() string {
 622         return "map_param_set_traffic_class"
 623 }
 624 func (*MapParamSetTrafficClass) GetCrcString() string {
 625         return "007ee563"
 626 }
 627 func (*MapParamSetTrafficClass) GetMessageType() api.MessageType {
 628         return api.RequestMessage
 629 }
 630
 631 // MapParamSetTrafficClassReply represents VPP binary API message 'map_param_set_traffic_class_reply':
 632 type MapParamSetTrafficClassReply struct {
 633         Retval int32
 634 }
 635
 636 func (*MapParamSetTrafficClassReply) GetMessageName() string {
 637         return "map_param_set_traffic_class_reply"
 638 }
 639 func (*MapParamSetTrafficClassReply) GetCrcString() string {
 640         return "e8d4e804"
 641 }
 642 func (*MapParamSetTrafficClassReply) GetMessageType() api.MessageType {
 643         return api.ReplyMessage
 644 }
 645
 646 // MapRuleDetails represents VPP binary API message 'map_rule_details':
 647 type MapRuleDetails struct {
 648         IP6Dst IP6Address
 649         Psid   uint16
 650 }
 651
 652 func (*MapRuleDetails) GetMessageName() string {
 653         return "map_rule_details"
 654 }
 655 func (*MapRuleDetails) GetCrcString() string {
 656         return "4f932665"
 657 }
 658 func (*MapRuleDetails) GetMessageType() api.MessageType {
 659         return api.ReplyMessage
 660 }
 661
 662 // MapRuleDump represents VPP binary API message 'map_rule_dump':
 663 type MapRuleDump struct {
 664         DomainIndex uint32
 665 }
 666
 667 func (*MapRuleDump) GetMessageName() string {
 668         return "map_rule_dump"
 669 }
 670 func (*MapRuleDump) GetCrcString() string {
 671         return "e43e6ff6"
 672 }
 673 func (*MapRuleDump) GetMessageType() api.MessageType {
 674         return api.RequestMessage
 675 }
 676
 677 // MapSummaryStats represents VPP binary API message 'map_summary_stats':
 678 type MapSummaryStats struct{}
 679
 680 func (*MapSummaryStats) GetMessageName() string {
 681         return "map_summary_stats"
 682 }
 683 func (*MapSummaryStats) GetCrcString() string {
 684         return "51077d14"
 685 }
 686 func (*MapSummaryStats) GetMessageType() api.MessageType {
 687         return api.RequestMessage
 688 }
 689
 690 // MapSummaryStatsReply represents VPP binary API message 'map_summary_stats_reply':
 691 type MapSummaryStatsReply struct {
 692         Retval             int32
 693         TotalBindings      uint64
 694         TotalPkts          []uint64 `struc:"[2]uint64"`
 695         TotalBytes         []uint64 `struc:"[2]uint64"`
 696         TotalIP4Fragments  uint64
 697         TotalSecurityCheck []uint64 `struc:"[2]uint64"`
 698 }
 699
 700 func (*MapSummaryStatsReply) GetMessageName() string {
 701         return "map_summary_stats_reply"
 702 }
 703 func (*MapSummaryStatsReply) GetCrcString() string {
 704         return "0e4ace0e"
 705 }
 706 func (*MapSummaryStatsReply) GetMessageType() api.MessageType {
 707         return api.ReplyMessage
 708 }
 709
 710 func init() {
 711         api.RegisterMessage((*MapAddDelRule)(nil), "map.MapAddDelRule")
 712         api.RegisterMessage((*MapAddDelRuleReply)(nil), "map.MapAddDelRuleReply")
 713         api.RegisterMessage((*MapAddDomain)(nil), "map.MapAddDomain")
 714         api.RegisterMessage((*MapAddDomainReply)(nil), "map.MapAddDomainReply")
 715         api.RegisterMessage((*MapDelDomain)(nil), "map.MapDelDomain")
 716         api.RegisterMessage((*MapDelDomainReply)(nil), "map.MapDelDomainReply")
 717         api.RegisterMessage((*MapDomainDetails)(nil), "map.MapDomainDetails")
 718         api.RegisterMessage((*MapDomainDump)(nil), "map.MapDomainDump")
 719         api.RegisterMessage((*MapIfEnableDisable)(nil), "map.MapIfEnableDisable")
 720         api.RegisterMessage((*MapIfEnableDisableReply)(nil), "map.MapIfEnableDisableReply")
 721         api.RegisterMessage((*MapParamAddDelPreResolve)(nil), "map.MapParamAddDelPreResolve")
 722         api.RegisterMessage((*MapParamAddDelPreResolveReply)(nil), "map.MapParamAddDelPreResolveReply")
 723         api.RegisterMessage((*MapParamGet)(nil), "map.MapParamGet")
 724         api.RegisterMessage((*MapParamGetReply)(nil), "map.MapParamGetReply")
 725         api.RegisterMessage((*MapParamSetFragmentation)(nil), "map.MapParamSetFragmentation")
 726         api.RegisterMessage((*MapParamSetFragmentationReply)(nil), "map.MapParamSetFragmentationReply")
 727         api.RegisterMessage((*MapParamSetICMP)(nil), "map.MapParamSetICMP")
 728         api.RegisterMessage((*MapParamSetICMP6)(nil), "map.MapParamSetICMP6")
 729         api.RegisterMessage((*MapParamSetICMP6Reply)(nil), "map.MapParamSetICMP6Reply")
 730         api.RegisterMessage((*MapParamSetICMPReply)(nil), "map.MapParamSetICMPReply")
 731         api.RegisterMessage((*MapParamSetReassembly)(nil), "map.MapParamSetReassembly")
 732         api.RegisterMessage((*MapParamSetReassemblyReply)(nil), "map.MapParamSetReassemblyReply")
 733         api.RegisterMessage((*MapParamSetSecurityCheck)(nil), "map.MapParamSetSecurityCheck")
 734         api.RegisterMessage((*MapParamSetSecurityCheckReply)(nil), "map.MapParamSetSecurityCheckReply")
 735         api.RegisterMessage((*MapParamSetTCP)(nil), "map.MapParamSetTCP")
 736         api.RegisterMessage((*MapParamSetTCPReply)(nil), "map.MapParamSetTCPReply")
 737         api.RegisterMessage((*MapParamSetTrafficClass)(nil), "map.MapParamSetTrafficClass")
 738         api.RegisterMessage((*MapParamSetTrafficClassReply)(nil), "map.MapParamSetTrafficClassReply")
 739         api.RegisterMessage((*MapRuleDetails)(nil), "map.MapRuleDetails")
 740         api.RegisterMessage((*MapRuleDump)(nil), "map.MapRuleDump")
 741         api.RegisterMessage((*MapSummaryStats)(nil), "map.MapSummaryStats")
 742         api.RegisterMessage((*MapSummaryStatsReply)(nil), "map.MapSummaryStatsReply")
 743 }