examples/binapi/vpe/vpe.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/vpe.api.json
   6
   7 /*
   8 Package vpe contains generated code for VPP API file vpe.api (1.6.1).
   9
  10 It consists of:
  11           2 aliases
  12           1 enum
  13          26 messages
  14           2 types
  15 */
  16 package vpe
  17
  18 import (
  19         "bytes"
  20         "context"
  21         "encoding/binary"
  22         "fmt"
  23         "io"
  24         "math"
  25         "net"
  26         "strconv"
  27         "strings"
  28
  29         api "git.fd.io/govpp.git/api"
  30         codec "git.fd.io/govpp.git/codec"
  31         struc "github.com/lunixbochs/struc"
  32 )
  33
  34 // This is a compile-time assertion to ensure that this generated file
  35 // is compatible with the GoVPP api package it is being compiled against.
  36 // A compilation error at this line likely means your copy of the
  37 // GoVPP api package needs to be updated.
  38 const _ = api.GoVppAPIPackageIsVersion2 // please upgrade the GoVPP api package
  39
  40 const (
  41         // ModuleName is the name of this module.
  42         ModuleName = "vpe"
  43         // APIVersion is the API version of this module.
  44         APIVersion = "1.6.1"
  45         // VersionCrc is the CRC of this module.
  46         VersionCrc = 0xbd2c94f4
  47 )
  48
  49 // LogLevel represents VPP binary API enum 'log_level'.
  50 type LogLevel uint32
  51
  52 const (
  53         VPE_API_LOG_LEVEL_EMERG    LogLevel = 0
  54         VPE_API_LOG_LEVEL_ALERT    LogLevel = 1
  55         VPE_API_LOG_LEVEL_CRIT     LogLevel = 2
  56         VPE_API_LOG_LEVEL_ERR      LogLevel = 3
  57         VPE_API_LOG_LEVEL_WARNING  LogLevel = 4
  58         VPE_API_LOG_LEVEL_NOTICE   LogLevel = 5
  59         VPE_API_LOG_LEVEL_INFO     LogLevel = 6
  60         VPE_API_LOG_LEVEL_DEBUG    LogLevel = 7
  61         VPE_API_LOG_LEVEL_DISABLED LogLevel = 8
  62 )
  63
  64 var (
  65         LogLevel_name = map[uint32]string{
  66                 0: "VPE_API_LOG_LEVEL_EMERG",
  67                 1: "VPE_API_LOG_LEVEL_ALERT",
  68                 2: "VPE_API_LOG_LEVEL_CRIT",
  69                 3: "VPE_API_LOG_LEVEL_ERR",
  70                 4: "VPE_API_LOG_LEVEL_WARNING",
  71                 5: "VPE_API_LOG_LEVEL_NOTICE",
  72                 6: "VPE_API_LOG_LEVEL_INFO",
  73                 7: "VPE_API_LOG_LEVEL_DEBUG",
  74                 8: "VPE_API_LOG_LEVEL_DISABLED",
  75         }
  76         LogLevel_value = map[string]uint32{
  77                 "VPE_API_LOG_LEVEL_EMERG":    0,
  78                 "VPE_API_LOG_LEVEL_ALERT":    1,
  79                 "VPE_API_LOG_LEVEL_CRIT":     2,
  80                 "VPE_API_LOG_LEVEL_ERR":      3,
  81                 "VPE_API_LOG_LEVEL_WARNING":  4,
  82                 "VPE_API_LOG_LEVEL_NOTICE":   5,
  83                 "VPE_API_LOG_LEVEL_INFO":     6,
  84                 "VPE_API_LOG_LEVEL_DEBUG":    7,
  85                 "VPE_API_LOG_LEVEL_DISABLED": 8,
  86         }
  87 )
  88
  89 func (x LogLevel) String() string {
  90         s, ok := LogLevel_name[uint32(x)]
  91         if ok {
  92                 return s
  93         }
  94         return "LogLevel(" + strconv.Itoa(int(x)) + ")"
  95 }
  96
  97 // Timedelta represents VPP binary API alias 'timedelta'.
  98 type Timedelta float64
  99
 100 // Timestamp represents VPP binary API alias 'timestamp'.
 101 type Timestamp float64
 102
 103 // ThreadData represents VPP binary API type 'thread_data'.
 104 type ThreadData struct {
 105         ID        uint32 `binapi:"u32,name=id" json:"id,omitempty"`
 106         Name      string `binapi:"string[64],name=name" json:"name,omitempty" struc:"[64]byte"`
 107         Type      string `binapi:"string[64],name=type" json:"type,omitempty" struc:"[64]byte"`
 108         PID       uint32 `binapi:"u32,name=pid" json:"pid,omitempty"`
 109         CPUID     uint32 `binapi:"u32,name=cpu_id" json:"cpu_id,omitempty"`
 110         Core      uint32 `binapi:"u32,name=core" json:"core,omitempty"`
 111         CPUSocket uint32 `binapi:"u32,name=cpu_socket" json:"cpu_socket,omitempty"`
 112 }
 113
 114 func (*ThreadData) GetTypeName() string { return "thread_data" }
 115
 116 // Version represents VPP binary API type 'version'.
 117 type Version struct {
 118         Major         uint32 `binapi:"u32,name=major" json:"major,omitempty"`
 119         Minor         uint32 `binapi:"u32,name=minor" json:"minor,omitempty"`
 120         Patch         uint32 `binapi:"u32,name=patch" json:"patch,omitempty"`
 121         PreRelease    []byte `binapi:"u8[17],name=pre_release" json:"pre_release,omitempty" struc:"[17]byte"`
 122         BuildMetadata []byte `binapi:"u8[17],name=build_metadata" json:"build_metadata,omitempty" struc:"[17]byte"`
 123 }
 124
 125 func (*Version) GetTypeName() string { return "version" }
 126
 127 // AddNodeNext represents VPP binary API message 'add_node_next'.
 128 type AddNodeNext struct {
 129         NodeName string `binapi:"string[64],name=node_name" json:"node_name,omitempty" struc:"[64]byte"`
 130         NextName string `binapi:"string[64],name=next_name" json:"next_name,omitempty" struc:"[64]byte"`
 131 }
 132
 133 func (m *AddNodeNext) Reset()                        { *m = AddNodeNext{} }
 134 func (*AddNodeNext) GetMessageName() string          { return "add_node_next" }
 135 func (*AddNodeNext) GetCrcString() string            { return "2457116d" }
 136 func (*AddNodeNext) GetMessageType() api.MessageType { return api.RequestMessage }
 137
 138 func (m *AddNodeNext) Size() int {
 139         if m == nil {
 140                 return 0
 141         }
 142         var size int
 143         // field[1] m.NodeName
 144         size += 64
 145         // field[1] m.NextName
 146         size += 64
 147         return size
 148 }
 149 func (m *AddNodeNext) Marshal(b []byte) ([]byte, error) {
 150         o := binary.BigEndian
 151         _ = o
 152         pos := 0
 153         _ = pos
 154         var buf []byte
 155         if b == nil {
 156                 buf = make([]byte, m.Size())
 157         } else {
 158                 buf = b
 159         }
 160         // field[1] m.NodeName
 161         copy(buf[pos:pos+64], m.NodeName)
 162         pos += 64
 163         // field[1] m.NextName
 164         copy(buf[pos:pos+64], m.NextName)
 165         pos += 64
 166         return buf, nil
 167 }
 168 func (m *AddNodeNext) Unmarshal(tmp []byte) error {
 169         o := binary.BigEndian
 170         _ = o
 171         pos := 0
 172         _ = pos
 173         // field[1] m.NodeName
 174         {
 175                 nul := bytes.Index(tmp[pos:pos+64], []byte{0x00})
 176                 m.NodeName = codec.DecodeString(tmp[pos : pos+nul])
 177                 pos += 64
 178         }
 179         // field[1] m.NextName
 180         {
 181                 nul := bytes.Index(tmp[pos:pos+64], []byte{0x00})
 182                 m.NextName = codec.DecodeString(tmp[pos : pos+nul])
 183                 pos += 64
 184         }
 185         return nil
 186 }
 187
 188 // AddNodeNextReply represents VPP binary API message 'add_node_next_reply'.
 189 type AddNodeNextReply struct {
 190         Retval    int32  `binapi:"i32,name=retval" json:"retval,omitempty"`
 191         NextIndex uint32 `binapi:"u32,name=next_index" json:"next_index,omitempty"`
 192 }
 193
 194 func (m *AddNodeNextReply) Reset()                        { *m = AddNodeNextReply{} }
 195 func (*AddNodeNextReply) GetMessageName() string          { return "add_node_next_reply" }
 196 func (*AddNodeNextReply) GetCrcString() string            { return "2ed75f32" }
 197 func (*AddNodeNextReply) GetMessageType() api.MessageType { return api.ReplyMessage }
 198
 199 func (m *AddNodeNextReply) Size() int {
 200         if m == nil {
 201                 return 0
 202         }
 203         var size int
 204         // field[1] m.Retval
 205         size += 4
 206         // field[1] m.NextIndex
 207         size += 4
 208         return size
 209 }
 210 func (m *AddNodeNextReply) Marshal(b []byte) ([]byte, error) {
 211         o := binary.BigEndian
 212         _ = o
 213         pos := 0
 214         _ = pos
 215         var buf []byte
 216         if b == nil {
 217                 buf = make([]byte, m.Size())
 218         } else {
 219                 buf = b
 220         }
 221         // field[1] m.Retval
 222         o.PutUint32(buf[pos:pos+4], uint32(m.Retval))
 223         pos += 4
 224         // field[1] m.NextIndex
 225         o.PutUint32(buf[pos:pos+4], uint32(m.NextIndex))
 226         pos += 4
 227         return buf, nil
 228 }
 229 func (m *AddNodeNextReply) Unmarshal(tmp []byte) error {
 230         o := binary.BigEndian
 231         _ = o
 232         pos := 0
 233         _ = pos
 234         // field[1] m.Retval
 235         m.Retval = int32(o.Uint32(tmp[pos : pos+4]))
 236         pos += 4
 237         // field[1] m.NextIndex
 238         m.NextIndex = uint32(o.Uint32(tmp[pos : pos+4]))
 239         pos += 4
 240         return nil
 241 }
 242
 243 // Cli represents VPP binary API message 'cli'.
 244 type Cli struct {
 245         CmdInShmem uint64 `binapi:"u64,name=cmd_in_shmem" json:"cmd_in_shmem,omitempty"`
 246 }
 247
 248 func (m *Cli) Reset()                        { *m = Cli{} }
 249 func (*Cli) GetMessageName() string          { return "cli" }
 250 func (*Cli) GetCrcString() string            { return "23bfbfff" }
 251 func (*Cli) GetMessageType() api.MessageType { return api.RequestMessage }
 252
 253 func (m *Cli) Size() int {
 254         if m == nil {
 255                 return 0
 256         }
 257         var size int
 258         // field[1] m.CmdInShmem
 259         size += 8
 260         return size
 261 }
 262 func (m *Cli) Marshal(b []byte) ([]byte, error) {
 263         o := binary.BigEndian
 264         _ = o
 265         pos := 0
 266         _ = pos
 267         var buf []byte
 268         if b == nil {
 269                 buf = make([]byte, m.Size())
 270         } else {
 271                 buf = b
 272         }
 273         // field[1] m.CmdInShmem
 274         o.PutUint64(buf[pos:pos+8], uint64(m.CmdInShmem))
 275         pos += 8
 276         return buf, nil
 277 }
 278 func (m *Cli) Unmarshal(tmp []byte) error {
 279         o := binary.BigEndian
 280         _ = o
 281         pos := 0
 282         _ = pos
 283         // field[1] m.CmdInShmem
 284         m.CmdInShmem = uint64(o.Uint64(tmp[pos : pos+8]))
 285         pos += 8
 286         return nil
 287 }
 288
 289 // CliInband represents VPP binary API message 'cli_inband'.
 290 type CliInband struct {
 291         XXX_CmdLen uint32 `struc:"sizeof=Cmd"`
 292         Cmd        string `json:"cmd,omitempty"`
 293 }
 294
 295 func (m *CliInband) Reset()                        { *m = CliInband{} }
 296 func (*CliInband) GetMessageName() string          { return "cli_inband" }
 297 func (*CliInband) GetCrcString() string            { return "f8377302" }
 298 func (*CliInband) GetMessageType() api.MessageType { return api.RequestMessage }
 299
 300 func (m *CliInband) Size() int {
 301         if m == nil {
 302                 return 0
 303         }
 304         var size int
 305         // field[1] m.Cmd
 306         size += 4 + len(m.Cmd)
 307         return size
 308 }
 309 func (m *CliInband) Marshal(b []byte) ([]byte, error) {
 310         o := binary.BigEndian
 311         _ = o
 312         pos := 0
 313         _ = pos
 314         var buf []byte
 315         if b == nil {
 316                 buf = make([]byte, m.Size())
 317         } else {
 318                 buf = b
 319         }
 320         // field[1] m.Cmd
 321         o.PutUint32(buf[pos:pos+4], uint32(len(m.Cmd)))
 322         pos += 4
 323         copy(buf[pos:pos+len(m.Cmd)], m.Cmd[:])
 324         pos += len(m.Cmd)
 325         return buf, nil
 326 }
 327 func (m *CliInband) Unmarshal(tmp []byte) error {
 328         o := binary.BigEndian
 329         _ = o
 330         pos := 0
 331         _ = pos
 332         // field[1] m.Cmd
 333         {
 334                 siz := o.Uint32(tmp[pos : pos+4])
 335                 pos += 4
 336                 m.Cmd = codec.DecodeString(tmp[pos : pos+int(siz)])
 337                 pos += len(m.Cmd)
 338         }
 339         return nil
 340 }
 341
 342 // CliInbandReply represents VPP binary API message 'cli_inband_reply'.
 343 type CliInbandReply struct {
 344         Retval       int32  `binapi:"i32,name=retval" json:"retval,omitempty"`
 345         XXX_ReplyLen uint32 `struc:"sizeof=Reply"`
 346         Reply        string `json:"reply,omitempty"`
 347 }
 348
 349 func (m *CliInbandReply) Reset()                        { *m = CliInbandReply{} }
 350 func (*CliInbandReply) GetMessageName() string          { return "cli_inband_reply" }
 351 func (*CliInbandReply) GetCrcString() string            { return "05879051" }
 352 func (*CliInbandReply) GetMessageType() api.MessageType { return api.ReplyMessage }
 353
 354 func (m *CliInbandReply) Size() int {
 355         if m == nil {
 356                 return 0
 357         }
 358         var size int
 359         // field[1] m.Retval
 360         size += 4
 361         // field[1] m.Reply
 362         size += 4 + len(m.Reply)
 363         return size
 364 }
 365 func (m *CliInbandReply) Marshal(b []byte) ([]byte, error) {
 366         o := binary.BigEndian
 367         _ = o
 368         pos := 0
 369         _ = pos
 370         var buf []byte
 371         if b == nil {
 372                 buf = make([]byte, m.Size())
 373         } else {
 374                 buf = b
 375         }
 376         // field[1] m.Retval
 377         o.PutUint32(buf[pos:pos+4], uint32(m.Retval))
 378         pos += 4
 379         // field[1] m.Reply
 380         o.PutUint32(buf[pos:pos+4], uint32(len(m.Reply)))
 381         pos += 4
 382         copy(buf[pos:pos+len(m.Reply)], m.Reply[:])
 383         pos += len(m.Reply)
 384         return buf, nil
 385 }
 386 func (m *CliInbandReply) Unmarshal(tmp []byte) error {
 387         o := binary.BigEndian
 388         _ = o
 389         pos := 0
 390         _ = pos
 391         // field[1] m.Retval
 392         m.Retval = int32(o.Uint32(tmp[pos : pos+4]))
 393         pos += 4
 394         // field[1] m.Reply
 395         {
 396                 siz := o.Uint32(tmp[pos : pos+4])
 397                 pos += 4
 398                 m.Reply = codec.DecodeString(tmp[pos : pos+int(siz)])
 399                 pos += len(m.Reply)
 400         }
 401         return nil
 402 }
 403
 404 // CliReply represents VPP binary API message 'cli_reply'.
 405 type CliReply struct {
 406         Retval       int32  `binapi:"i32,name=retval" json:"retval,omitempty"`
 407         ReplyInShmem uint64 `binapi:"u64,name=reply_in_shmem" json:"reply_in_shmem,omitempty"`
 408 }
 409
 410 func (m *CliReply) Reset()                        { *m = CliReply{} }
 411 func (*CliReply) GetMessageName() string          { return "cli_reply" }
 412 func (*CliReply) GetCrcString() string            { return "06d68297" }
 413 func (*CliReply) GetMessageType() api.MessageType { return api.ReplyMessage }
 414
 415 func (m *CliReply) Size() int {
 416         if m == nil {
 417                 return 0
 418         }
 419         var size int
 420         // field[1] m.Retval
 421         size += 4
 422         // field[1] m.ReplyInShmem
 423         size += 8
 424         return size
 425 }
 426 func (m *CliReply) Marshal(b []byte) ([]byte, error) {
 427         o := binary.BigEndian
 428         _ = o
 429         pos := 0
 430         _ = pos
 431         var buf []byte
 432         if b == nil {
 433                 buf = make([]byte, m.Size())
 434         } else {
 435                 buf = b
 436         }
 437         // field[1] m.Retval
 438         o.PutUint32(buf[pos:pos+4], uint32(m.Retval))
 439         pos += 4
 440         // field[1] m.ReplyInShmem
 441         o.PutUint64(buf[pos:pos+8], uint64(m.ReplyInShmem))
 442         pos += 8
 443         return buf, nil
 444 }
 445 func (m *CliReply) Unmarshal(tmp []byte) error {
 446         o := binary.BigEndian
 447         _ = o
 448         pos := 0
 449         _ = pos
 450         // field[1] m.Retval
 451         m.Retval = int32(o.Uint32(tmp[pos : pos+4]))
 452         pos += 4
 453         // field[1] m.ReplyInShmem
 454         m.ReplyInShmem = uint64(o.Uint64(tmp[pos : pos+8]))
 455         pos += 8
 456         return nil
 457 }
 458
 459 // ControlPing represents VPP binary API message 'control_ping'.
 460 type ControlPing struct{}
 461
 462 func (m *ControlPing) Reset()                        { *m = ControlPing{} }
 463 func (*ControlPing) GetMessageName() string          { return "control_ping" }
 464 func (*ControlPing) GetCrcString() string            { return "51077d14" }
 465 func (*ControlPing) GetMessageType() api.MessageType { return api.RequestMessage }
 466
 467 func (m *ControlPing) Size() int {
 468         if m == nil {
 469                 return 0
 470         }
 471         var size int
 472         return size
 473 }
 474 func (m *ControlPing) Marshal(b []byte) ([]byte, error) {
 475         o := binary.BigEndian
 476         _ = o
 477         pos := 0
 478         _ = pos
 479         var buf []byte
 480         if b == nil {
 481                 buf = make([]byte, m.Size())
 482         } else {
 483                 buf = b
 484         }
 485         return buf, nil
 486 }
 487 func (m *ControlPing) Unmarshal(tmp []byte) error {
 488         o := binary.BigEndian
 489         _ = o
 490         pos := 0
 491         _ = pos
 492         return nil
 493 }
 494
 495 // ControlPingReply represents VPP binary API message 'control_ping_reply'.
 496 type ControlPingReply struct {
 497         Retval      int32  `binapi:"i32,name=retval" json:"retval,omitempty"`
 498         ClientIndex uint32 `binapi:"u32,name=client_index" json:"client_index,omitempty"`
 499         VpePID      uint32 `binapi:"u32,name=vpe_pid" json:"vpe_pid,omitempty"`
 500 }
 501
 502 func (m *ControlPingReply) Reset()                        { *m = ControlPingReply{} }
 503 func (*ControlPingReply) GetMessageName() string          { return "control_ping_reply" }
 504 func (*ControlPingReply) GetCrcString() string            { return "f6b0b8ca" }
 505 func (*ControlPingReply) GetMessageType() api.MessageType { return api.ReplyMessage }
 506
 507 func (m *ControlPingReply) Size() int {
 508         if m == nil {
 509                 return 0
 510         }
 511         var size int
 512         // field[1] m.Retval
 513         size += 4
 514         // field[1] m.ClientIndex
 515         size += 4
 516         // field[1] m.VpePID
 517         size += 4
 518         return size
 519 }
 520 func (m *ControlPingReply) Marshal(b []byte) ([]byte, error) {
 521         o := binary.BigEndian
 522         _ = o
 523         pos := 0
 524         _ = pos
 525         var buf []byte
 526         if b == nil {
 527                 buf = make([]byte, m.Size())
 528         } else {
 529                 buf = b
 530         }
 531         // field[1] m.Retval
 532         o.PutUint32(buf[pos:pos+4], uint32(m.Retval))
 533         pos += 4
 534         // field[1] m.ClientIndex
 535         o.PutUint32(buf[pos:pos+4], uint32(m.ClientIndex))
 536         pos += 4
 537         // field[1] m.VpePID
 538         o.PutUint32(buf[pos:pos+4], uint32(m.VpePID))
 539         pos += 4
 540         return buf, nil
 541 }
 542 func (m *ControlPingReply) Unmarshal(tmp []byte) error {
 543         o := binary.BigEndian
 544         _ = o
 545         pos := 0
 546         _ = pos
 547         // field[1] m.Retval
 548         m.Retval = int32(o.Uint32(tmp[pos : pos+4]))
 549         pos += 4
 550         // field[1] m.ClientIndex
 551         m.ClientIndex = uint32(o.Uint32(tmp[pos : pos+4]))
 552         pos += 4
 553         // field[1] m.VpePID
 554         m.VpePID = uint32(o.Uint32(tmp[pos : pos+4]))
 555         pos += 4
 556         return nil
 557 }
 558
 559 // GetF64EndianValue represents VPP binary API message 'get_f64_endian_value'.
 560 type GetF64EndianValue struct {
 561         F64One float64 `binapi:"f64,name=f64_one,default=1" json:"f64_one,omitempty"`
 562 }
 563
 564 func (m *GetF64EndianValue) Reset()                        { *m = GetF64EndianValue{} }
 565 func (*GetF64EndianValue) GetMessageName() string          { return "get_f64_endian_value" }
 566 func (*GetF64EndianValue) GetCrcString() string            { return "809fcd44" }
 567 func (*GetF64EndianValue) GetMessageType() api.MessageType { return api.RequestMessage }
 568
 569 func (m *GetF64EndianValue) Size() int {
 570         if m == nil {
 571                 return 0
 572         }
 573         var size int
 574         // field[1] m.F64One
 575         size += 8
 576         return size
 577 }
 578 func (m *GetF64EndianValue) Marshal(b []byte) ([]byte, error) {
 579         o := binary.BigEndian
 580         _ = o
 581         pos := 0
 582         _ = pos
 583         var buf []byte
 584         if b == nil {
 585                 buf = make([]byte, m.Size())
 586         } else {
 587                 buf = b
 588         }
 589         // field[1] m.F64One
 590         o.PutUint64(buf[pos:pos+8], math.Float64bits(float64(m.F64One)))
 591         pos += 8
 592         return buf, nil
 593 }
 594 func (m *GetF64EndianValue) Unmarshal(tmp []byte) error {
 595         o := binary.BigEndian
 596         _ = o
 597         pos := 0
 598         _ = pos
 599         // field[1] m.F64One
 600         m.F64One = float64(math.Float64frombits(o.Uint64(tmp[pos : pos+8])))
 601         pos += 8
 602         return nil
 603 }
 604
 605 // GetF64EndianValueReply represents VPP binary API message 'get_f64_endian_value_reply'.
 606 type GetF64EndianValueReply struct {
 607         Retval       uint32  `binapi:"u32,name=retval" json:"retval,omitempty"`
 608         F64OneResult float64 `binapi:"f64,name=f64_one_result" json:"f64_one_result,omitempty"`
 609 }
 610
 611 func (m *GetF64EndianValueReply) Reset()                        { *m = GetF64EndianValueReply{} }
 612 func (*GetF64EndianValueReply) GetMessageName() string          { return "get_f64_endian_value_reply" }
 613 func (*GetF64EndianValueReply) GetCrcString() string            { return "7e02e404" }
 614 func (*GetF64EndianValueReply) GetMessageType() api.MessageType { return api.ReplyMessage }
 615
 616 func (m *GetF64EndianValueReply) Size() int {
 617         if m == nil {
 618                 return 0
 619         }
 620         var size int
 621         // field[1] m.Retval
 622         size += 4
 623         // field[1] m.F64OneResult
 624         size += 8
 625         return size
 626 }
 627 func (m *GetF64EndianValueReply) Marshal(b []byte) ([]byte, error) {
 628         o := binary.BigEndian
 629         _ = o
 630         pos := 0
 631         _ = pos
 632         var buf []byte
 633         if b == nil {
 634                 buf = make([]byte, m.Size())
 635         } else {
 636                 buf = b
 637         }
 638         // field[1] m.Retval
 639         o.PutUint32(buf[pos:pos+4], uint32(m.Retval))
 640         pos += 4
 641         // field[1] m.F64OneResult
 642         o.PutUint64(buf[pos:pos+8], math.Float64bits(float64(m.F64OneResult)))
 643         pos += 8
 644         return buf, nil
 645 }
 646 func (m *GetF64EndianValueReply) Unmarshal(tmp []byte) error {
 647         o := binary.BigEndian
 648         _ = o
 649         pos := 0
 650         _ = pos
 651         // field[1] m.Retval
 652         m.Retval = uint32(o.Uint32(tmp[pos : pos+4]))
 653         pos += 4
 654         // field[1] m.F64OneResult
 655         m.F64OneResult = float64(math.Float64frombits(o.Uint64(tmp[pos : pos+8])))
 656         pos += 8
 657         return nil
 658 }
 659
 660 // GetF64IncrementByOne represents VPP binary API message 'get_f64_increment_by_one'.
 661 type GetF64IncrementByOne struct {
 662         F64Value float64 `binapi:"f64,name=f64_value,default=1" json:"f64_value,omitempty"`
 663 }
 664
 665 func (m *GetF64IncrementByOne) Reset()                        { *m = GetF64IncrementByOne{} }
 666 func (*GetF64IncrementByOne) GetMessageName() string          { return "get_f64_increment_by_one" }
 667 func (*GetF64IncrementByOne) GetCrcString() string            { return "b64f027e" }
 668 func (*GetF64IncrementByOne) GetMessageType() api.MessageType { return api.RequestMessage }
 669
 670 func (m *GetF64IncrementByOne) Size() int {
 671         if m == nil {
 672                 return 0
 673         }
 674         var size int
 675         // field[1] m.F64Value
 676         size += 8
 677         return size
 678 }
 679 func (m *GetF64IncrementByOne) Marshal(b []byte) ([]byte, error) {
 680         o := binary.BigEndian
 681         _ = o
 682         pos := 0
 683         _ = pos
 684         var buf []byte
 685         if b == nil {
 686                 buf = make([]byte, m.Size())
 687         } else {
 688                 buf = b
 689         }
 690         // field[1] m.F64Value
 691         o.PutUint64(buf[pos:pos+8], math.Float64bits(float64(m.F64Value)))
 692         pos += 8
 693         return buf, nil
 694 }
 695 func (m *GetF64IncrementByOne) Unmarshal(tmp []byte) error {
 696         o := binary.BigEndian
 697         _ = o
 698         pos := 0
 699         _ = pos
 700         // field[1] m.F64Value
 701         m.F64Value = float64(math.Float64frombits(o.Uint64(tmp[pos : pos+8])))
 702         pos += 8
 703         return nil
 704 }
 705
 706 // GetF64IncrementByOneReply represents VPP binary API message 'get_f64_increment_by_one_reply'.
 707 type GetF64IncrementByOneReply struct {
 708         Retval   uint32  `binapi:"u32,name=retval" json:"retval,omitempty"`
 709         F64Value float64 `binapi:"f64,name=f64_value" json:"f64_value,omitempty"`
 710 }
 711
 712 func (m *GetF64IncrementByOneReply) Reset()                        { *m = GetF64IncrementByOneReply{} }
 713 func (*GetF64IncrementByOneReply) GetMessageName() string          { return "get_f64_increment_by_one_reply" }
 714 func (*GetF64IncrementByOneReply) GetCrcString() string            { return "d25dbaa3" }
 715 func (*GetF64IncrementByOneReply) GetMessageType() api.MessageType { return api.ReplyMessage }
 716
 717 func (m *GetF64IncrementByOneReply) Size() int {
 718         if m == nil {
 719                 return 0
 720         }
 721         var size int
 722         // field[1] m.Retval
 723         size += 4
 724         // field[1] m.F64Value
 725         size += 8
 726         return size
 727 }
 728 func (m *GetF64IncrementByOneReply) Marshal(b []byte) ([]byte, error) {
 729         o := binary.BigEndian
 730         _ = o
 731         pos := 0
 732         _ = pos
 733         var buf []byte
 734         if b == nil {
 735                 buf = make([]byte, m.Size())
 736         } else {
 737                 buf = b
 738         }
 739         // field[1] m.Retval
 740         o.PutUint32(buf[pos:pos+4], uint32(m.Retval))
 741         pos += 4
 742         // field[1] m.F64Value
 743         o.PutUint64(buf[pos:pos+8], math.Float64bits(float64(m.F64Value)))
 744         pos += 8
 745         return buf, nil
 746 }
 747 func (m *GetF64IncrementByOneReply) Unmarshal(tmp []byte) error {
 748         o := binary.BigEndian
 749         _ = o
 750         pos := 0
 751         _ = pos
 752         // field[1] m.Retval
 753         m.Retval = uint32(o.Uint32(tmp[pos : pos+4]))
 754         pos += 4
 755         // field[1] m.F64Value
 756         m.F64Value = float64(math.Float64frombits(o.Uint64(tmp[pos : pos+8])))
 757         pos += 8
 758         return nil
 759 }
 760
 761 // GetNextIndex represents VPP binary API message 'get_next_index'.
 762 type GetNextIndex struct {
 763         NodeName string `binapi:"string[64],name=node_name" json:"node_name,omitempty" struc:"[64]byte"`
 764         NextName string `binapi:"string[64],name=next_name" json:"next_name,omitempty" struc:"[64]byte"`
 765 }
 766
 767 func (m *GetNextIndex) Reset()                        { *m = GetNextIndex{} }
 768 func (*GetNextIndex) GetMessageName() string          { return "get_next_index" }
 769 func (*GetNextIndex) GetCrcString() string            { return "2457116d" }
 770 func (*GetNextIndex) GetMessageType() api.MessageType { return api.RequestMessage }
 771
 772 func (m *GetNextIndex) Size() int {
 773         if m == nil {
 774                 return 0
 775         }
 776         var size int
 777         // field[1] m.NodeName
 778         size += 64
 779         // field[1] m.NextName
 780         size += 64
 781         return size
 782 }
 783 func (m *GetNextIndex) Marshal(b []byte) ([]byte, error) {
 784         o := binary.BigEndian
 785         _ = o
 786         pos := 0
 787         _ = pos
 788         var buf []byte
 789         if b == nil {
 790                 buf = make([]byte, m.Size())
 791         } else {
 792                 buf = b
 793         }
 794         // field[1] m.NodeName
 795         copy(buf[pos:pos+64], m.NodeName)
 796         pos += 64
 797         // field[1] m.NextName
 798         copy(buf[pos:pos+64], m.NextName)
 799         pos += 64
 800         return buf, nil
 801 }
 802 func (m *GetNextIndex) Unmarshal(tmp []byte) error {
 803         o := binary.BigEndian
 804         _ = o
 805         pos := 0
 806         _ = pos
 807         // field[1] m.NodeName
 808         {
 809                 nul := bytes.Index(tmp[pos:pos+64], []byte{0x00})
 810                 m.NodeName = codec.DecodeString(tmp[pos : pos+nul])
 811                 pos += 64
 812         }
 813         // field[1] m.NextName
 814         {
 815                 nul := bytes.Index(tmp[pos:pos+64], []byte{0x00})
 816                 m.NextName = codec.DecodeString(tmp[pos : pos+nul])
 817                 pos += 64
 818         }
 819         return nil
 820 }
 821
 822 // GetNextIndexReply represents VPP binary API message 'get_next_index_reply'.
 823 type GetNextIndexReply struct {
 824         Retval    int32  `binapi:"i32,name=retval" json:"retval,omitempty"`
 825         NextIndex uint32 `binapi:"u32,name=next_index" json:"next_index,omitempty"`
 826 }
 827
 828 func (m *GetNextIndexReply) Reset()                        { *m = GetNextIndexReply{} }
 829 func (*GetNextIndexReply) GetMessageName() string          { return "get_next_index_reply" }
 830 func (*GetNextIndexReply) GetCrcString() string            { return "2ed75f32" }
 831 func (*GetNextIndexReply) GetMessageType() api.MessageType { return api.ReplyMessage }
 832
 833 func (m *GetNextIndexReply) Size() int {
 834         if m == nil {
 835                 return 0
 836         }
 837         var size int
 838         // field[1] m.Retval
 839         size += 4
 840         // field[1] m.NextIndex
 841         size += 4
 842         return size
 843 }
 844 func (m *GetNextIndexReply) Marshal(b []byte) ([]byte, error) {
 845         o := binary.BigEndian
 846         _ = o
 847         pos := 0
 848         _ = pos
 849         var buf []byte
 850         if b == nil {
 851                 buf = make([]byte, m.Size())
 852         } else {
 853                 buf = b
 854         }
 855         // field[1] m.Retval
 856         o.PutUint32(buf[pos:pos+4], uint32(m.Retval))
 857         pos += 4
 858         // field[1] m.NextIndex
 859         o.PutUint32(buf[pos:pos+4], uint32(m.NextIndex))
 860         pos += 4
 861         return buf, nil
 862 }
 863 func (m *GetNextIndexReply) Unmarshal(tmp []byte) error {
 864         o := binary.BigEndian
 865         _ = o
 866         pos := 0
 867         _ = pos
 868         // field[1] m.Retval
 869         m.Retval = int32(o.Uint32(tmp[pos : pos+4]))
 870         pos += 4
 871         // field[1] m.NextIndex
 872         m.NextIndex = uint32(o.Uint32(tmp[pos : pos+4]))
 873         pos += 4
 874         return nil
 875 }
 876
 877 // GetNodeGraph represents VPP binary API message 'get_node_graph'.
 878 type GetNodeGraph struct{}
 879
 880 func (m *GetNodeGraph) Reset()                        { *m = GetNodeGraph{} }
 881 func (*GetNodeGraph) GetMessageName() string          { return "get_node_graph" }
 882 func (*GetNodeGraph) GetCrcString() string            { return "51077d14" }
 883 func (*GetNodeGraph) GetMessageType() api.MessageType { return api.RequestMessage }
 884
 885 func (m *GetNodeGraph) Size() int {
 886         if m == nil {
 887                 return 0
 888         }
 889         var size int
 890         return size
 891 }
 892 func (m *GetNodeGraph) Marshal(b []byte) ([]byte, error) {
 893         o := binary.BigEndian
 894         _ = o
 895         pos := 0
 896         _ = pos
 897         var buf []byte
 898         if b == nil {
 899                 buf = make([]byte, m.Size())
 900         } else {
 901                 buf = b
 902         }
 903         return buf, nil
 904 }
 905 func (m *GetNodeGraph) Unmarshal(tmp []byte) error {
 906         o := binary.BigEndian
 907         _ = o
 908         pos := 0
 909         _ = pos
 910         return nil
 911 }
 912
 913 // GetNodeGraphReply represents VPP binary API message 'get_node_graph_reply'.
 914 type GetNodeGraphReply struct {
 915         Retval       int32  `binapi:"i32,name=retval" json:"retval,omitempty"`
 916         ReplyInShmem uint64 `binapi:"u64,name=reply_in_shmem" json:"reply_in_shmem,omitempty"`
 917 }
 918
 919 func (m *GetNodeGraphReply) Reset()                        { *m = GetNodeGraphReply{} }
 920 func (*GetNodeGraphReply) GetMessageName() string          { return "get_node_graph_reply" }
 921 func (*GetNodeGraphReply) GetCrcString() string            { return "06d68297" }
 922 func (*GetNodeGraphReply) GetMessageType() api.MessageType { return api.ReplyMessage }
 923
 924 func (m *GetNodeGraphReply) Size() int {
 925         if m == nil {
 926                 return 0
 927         }
 928         var size int
 929         // field[1] m.Retval
 930         size += 4
 931         // field[1] m.ReplyInShmem
 932         size += 8
 933         return size
 934 }
 935 func (m *GetNodeGraphReply) Marshal(b []byte) ([]byte, error) {
 936         o := binary.BigEndian
 937         _ = o
 938         pos := 0
 939         _ = pos
 940         var buf []byte
 941         if b == nil {
 942                 buf = make([]byte, m.Size())
 943         } else {
 944                 buf = b
 945         }
 946         // field[1] m.Retval
 947         o.PutUint32(buf[pos:pos+4], uint32(m.Retval))
 948         pos += 4
 949         // field[1] m.ReplyInShmem
 950         o.PutUint64(buf[pos:pos+8], uint64(m.ReplyInShmem))
 951         pos += 8
 952         return buf, nil
 953 }
 954 func (m *GetNodeGraphReply) Unmarshal(tmp []byte) error {
 955         o := binary.BigEndian
 956         _ = o
 957         pos := 0
 958         _ = pos
 959         // field[1] m.Retval
 960         m.Retval = int32(o.Uint32(tmp[pos : pos+4]))
 961         pos += 4
 962         // field[1] m.ReplyInShmem
 963         m.ReplyInShmem = uint64(o.Uint64(tmp[pos : pos+8]))
 964         pos += 8
 965         return nil
 966 }
 967
 968 // GetNodeIndex represents VPP binary API message 'get_node_index'.
 969 type GetNodeIndex struct {
 970         NodeName string `binapi:"string[64],name=node_name" json:"node_name,omitempty" struc:"[64]byte"`
 971 }
 972
 973 func (m *GetNodeIndex) Reset()                        { *m = GetNodeIndex{} }
 974 func (*GetNodeIndex) GetMessageName() string          { return "get_node_index" }
 975 func (*GetNodeIndex) GetCrcString() string            { return "f1984c64" }
 976 func (*GetNodeIndex) GetMessageType() api.MessageType { return api.RequestMessage }
 977
 978 func (m *GetNodeIndex) Size() int {
 979         if m == nil {
 980                 return 0
 981         }
 982         var size int
 983         // field[1] m.NodeName
 984         size += 64
 985         return size
 986 }
 987 func (m *GetNodeIndex) Marshal(b []byte) ([]byte, error) {
 988         o := binary.BigEndian
 989         _ = o
 990         pos := 0
 991         _ = pos
 992         var buf []byte
 993         if b == nil {
 994                 buf = make([]byte, m.Size())
 995         } else {
 996                 buf = b
 997         }
 998         // field[1] m.NodeName
 999         copy(buf[pos:pos+64], m.NodeName)
1000         pos += 64
1001         return buf, nil
1002 }
1003 func (m *GetNodeIndex) Unmarshal(tmp []byte) error {
1004         o := binary.BigEndian
1005         _ = o
1006         pos := 0
1007         _ = pos
1008         // field[1] m.NodeName
1009         {
1010                 nul := bytes.Index(tmp[pos:pos+64], []byte{0x00})
1011                 m.NodeName = codec.DecodeString(tmp[pos : pos+nul])
1012                 pos += 64
1013         }
1014         return nil
1015 }
1016
1017 // GetNodeIndexReply represents VPP binary API message 'get_node_index_reply'.
1018 type GetNodeIndexReply struct {
1019         Retval    int32  `binapi:"i32,name=retval" json:"retval,omitempty"`
1020         NodeIndex uint32 `binapi:"u32,name=node_index" json:"node_index,omitempty"`
1021 }
1022
1023 func (m *GetNodeIndexReply) Reset()                        { *m = GetNodeIndexReply{} }
1024 func (*GetNodeIndexReply) GetMessageName() string          { return "get_node_index_reply" }
1025 func (*GetNodeIndexReply) GetCrcString() string            { return "a8600b89" }
1026 func (*GetNodeIndexReply) GetMessageType() api.MessageType { return api.ReplyMessage }
1027
1028 func (m *GetNodeIndexReply) Size() int {
1029         if m == nil {
1030                 return 0
1031         }
1032         var size int
1033         // field[1] m.Retval
1034         size += 4
1035         // field[1] m.NodeIndex
1036         size += 4
1037         return size
1038 }
1039 func (m *GetNodeIndexReply) Marshal(b []byte) ([]byte, error) {
1040         o := binary.BigEndian
1041         _ = o
1042         pos := 0
1043         _ = pos
1044         var buf []byte
1045         if b == nil {
1046                 buf = make([]byte, m.Size())
1047         } else {
1048                 buf = b
1049         }
1050         // field[1] m.Retval
1051         o.PutUint32(buf[pos:pos+4], uint32(m.Retval))
1052         pos += 4
1053         // field[1] m.NodeIndex
1054         o.PutUint32(buf[pos:pos+4], uint32(m.NodeIndex))
1055         pos += 4
1056         return buf, nil
1057 }
1058 func (m *GetNodeIndexReply) Unmarshal(tmp []byte) error {
1059         o := binary.BigEndian
1060         _ = o
1061         pos := 0
1062         _ = pos
1063         // field[1] m.Retval
1064         m.Retval = int32(o.Uint32(tmp[pos : pos+4]))
1065         pos += 4
1066         // field[1] m.NodeIndex
1067         m.NodeIndex = uint32(o.Uint32(tmp[pos : pos+4]))
1068         pos += 4
1069         return nil
1070 }
1071
1072 // LogDetails represents VPP binary API message 'log_details'.
1073 type LogDetails struct {
1074         Timestamp Timestamp `binapi:"timestamp,name=timestamp" json:"timestamp,omitempty"`
1075         Level     LogLevel  `binapi:"log_level,name=level" json:"level,omitempty"`
1076         MsgClass  string    `binapi:"string[32],name=msg_class" json:"msg_class,omitempty" struc:"[32]byte"`
1077         Message   string    `binapi:"string[256],name=message" json:"message,omitempty" struc:"[256]byte"`
1078 }
1079
1080 func (m *LogDetails) Reset()                        { *m = LogDetails{} }
1081 func (*LogDetails) GetMessageName() string          { return "log_details" }
1082 func (*LogDetails) GetCrcString() string            { return "255827a1" }
1083 func (*LogDetails) GetMessageType() api.MessageType { return api.ReplyMessage }
1084
1085 func (m *LogDetails) Size() int {
1086         if m == nil {
1087                 return 0
1088         }
1089         var size int
1090         // field[1] m.Timestamp
1091         size += 8
1092         // field[1] m.Level
1093         size += 4
1094         // field[1] m.MsgClass
1095         size += 32
1096         // field[1] m.Message
1097         size += 256
1098         return size
1099 }
1100 func (m *LogDetails) Marshal(b []byte) ([]byte, error) {
1101         o := binary.BigEndian
1102         _ = o
1103         pos := 0
1104         _ = pos
1105         var buf []byte
1106         if b == nil {
1107                 buf = make([]byte, m.Size())
1108         } else {
1109                 buf = b
1110         }
1111         // field[1] m.Timestamp
1112         o.PutUint64(buf[pos:pos+8], math.Float64bits(float64(m.Timestamp)))
1113         pos += 8
1114         // field[1] m.Level
1115         o.PutUint32(buf[pos:pos+4], uint32(m.Level))
1116         pos += 4
1117         // field[1] m.MsgClass
1118         copy(buf[pos:pos+32], m.MsgClass)
1119         pos += 32
1120         // field[1] m.Message
1121         copy(buf[pos:pos+256], m.Message)
1122         pos += 256
1123         return buf, nil
1124 }
1125 func (m *LogDetails) Unmarshal(tmp []byte) error {
1126         o := binary.BigEndian
1127         _ = o
1128         pos := 0
1129         _ = pos
1130         // field[1] m.Timestamp
1131         m.Timestamp = Timestamp(math.Float64frombits(o.Uint64(tmp[pos : pos+8])))
1132         pos += 8
1133         // field[1] m.Level
1134         m.Level = LogLevel(o.Uint32(tmp[pos : pos+4]))
1135         pos += 4
1136         // field[1] m.MsgClass
1137         {
1138                 nul := bytes.Index(tmp[pos:pos+32], []byte{0x00})
1139                 m.MsgClass = codec.DecodeString(tmp[pos : pos+nul])
1140                 pos += 32
1141         }
1142         // field[1] m.Message
1143         {
1144                 nul := bytes.Index(tmp[pos:pos+256], []byte{0x00})
1145                 m.Message = codec.DecodeString(tmp[pos : pos+nul])
1146                 pos += 256
1147         }
1148         return nil
1149 }
1150
1151 // LogDump represents VPP binary API message 'log_dump'.
1152 type LogDump struct {
1153         StartTimestamp Timestamp `binapi:"timestamp,name=start_timestamp" json:"start_timestamp,omitempty"`
1154 }
1155
1156 func (m *LogDump) Reset()                        { *m = LogDump{} }
1157 func (*LogDump) GetMessageName() string          { return "log_dump" }
1158 func (*LogDump) GetCrcString() string            { return "6ab31753" }
1159 func (*LogDump) GetMessageType() api.MessageType { return api.RequestMessage }
1160
1161 func (m *LogDump) Size() int {
1162         if m == nil {
1163                 return 0
1164         }
1165         var size int
1166         // field[1] m.StartTimestamp
1167         size += 8
1168         return size
1169 }
1170 func (m *LogDump) Marshal(b []byte) ([]byte, error) {
1171         o := binary.BigEndian
1172         _ = o
1173         pos := 0
1174         _ = pos
1175         var buf []byte
1176         if b == nil {
1177                 buf = make([]byte, m.Size())
1178         } else {
1179                 buf = b
1180         }
1181         // field[1] m.StartTimestamp
1182         o.PutUint64(buf[pos:pos+8], math.Float64bits(float64(m.StartTimestamp)))
1183         pos += 8
1184         return buf, nil
1185 }
1186 func (m *LogDump) Unmarshal(tmp []byte) error {
1187         o := binary.BigEndian
1188         _ = o
1189         pos := 0
1190         _ = pos
1191         // field[1] m.StartTimestamp
1192         m.StartTimestamp = Timestamp(math.Float64frombits(o.Uint64(tmp[pos : pos+8])))
1193         pos += 8
1194         return nil
1195 }
1196
1197 // ShowThreads represents VPP binary API message 'show_threads'.
1198 type ShowThreads struct{}
1199
1200 func (m *ShowThreads) Reset()                        { *m = ShowThreads{} }
1201 func (*ShowThreads) GetMessageName() string          { return "show_threads" }
1202 func (*ShowThreads) GetCrcString() string            { return "51077d14" }
1203 func (*ShowThreads) GetMessageType() api.MessageType { return api.RequestMessage }
1204
1205 func (m *ShowThreads) Size() int {
1206         if m == nil {
1207                 return 0
1208         }
1209         var size int
1210         return size
1211 }
1212 func (m *ShowThreads) Marshal(b []byte) ([]byte, error) {
1213         o := binary.BigEndian
1214         _ = o
1215         pos := 0
1216         _ = pos
1217         var buf []byte
1218         if b == nil {
1219                 buf = make([]byte, m.Size())
1220         } else {
1221                 buf = b
1222         }
1223         return buf, nil
1224 }
1225 func (m *ShowThreads) Unmarshal(tmp []byte) error {
1226         o := binary.BigEndian
1227         _ = o
1228         pos := 0
1229         _ = pos
1230         return nil
1231 }
1232
1233 // ShowThreadsReply represents VPP binary API message 'show_threads_reply'.
1234 type ShowThreadsReply struct {
1235         Retval     int32        `binapi:"i32,name=retval" json:"retval,omitempty"`
1236         Count      uint32       `binapi:"u32,name=count" json:"count,omitempty" struc:"sizeof=ThreadData"`
1237         ThreadData []ThreadData `binapi:"thread_data[count],name=thread_data" json:"thread_data,omitempty"`
1238 }
1239
1240 func (m *ShowThreadsReply) Reset()                        { *m = ShowThreadsReply{} }
1241 func (*ShowThreadsReply) GetMessageName() string          { return "show_threads_reply" }
1242 func (*ShowThreadsReply) GetCrcString() string            { return "efd78e83" }
1243 func (*ShowThreadsReply) GetMessageType() api.MessageType { return api.ReplyMessage }
1244
1245 func (m *ShowThreadsReply) Size() int {
1246         if m == nil {
1247                 return 0
1248         }
1249         var size int
1250         // field[1] m.Retval
1251         size += 4
1252         // field[1] m.Count
1253         size += 4
1254         // field[1] m.ThreadData
1255         for j1 := 0; j1 < len(m.ThreadData); j1++ {
1256                 var s1 ThreadData
1257                 _ = s1
1258                 if j1 < len(m.ThreadData) {
1259                         s1 = m.ThreadData[j1]
1260                 }
1261                 // field[2] s1.ID
1262                 size += 4
1263                 // field[2] s1.Name
1264                 size += 64
1265                 // field[2] s1.Type
1266                 size += 64
1267                 // field[2] s1.PID
1268                 size += 4
1269                 // field[2] s1.CPUID
1270                 size += 4
1271                 // field[2] s1.Core
1272                 size += 4
1273                 // field[2] s1.CPUSocket
1274                 size += 4
1275         }
1276         return size
1277 }
1278 func (m *ShowThreadsReply) Marshal(b []byte) ([]byte, error) {
1279         o := binary.BigEndian
1280         _ = o
1281         pos := 0
1282         _ = pos
1283         var buf []byte
1284         if b == nil {
1285                 buf = make([]byte, m.Size())
1286         } else {
1287                 buf = b
1288         }
1289         // field[1] m.Retval
1290         o.PutUint32(buf[pos:pos+4], uint32(m.Retval))
1291         pos += 4
1292         // field[1] m.Count
1293         o.PutUint32(buf[pos:pos+4], uint32(len(m.ThreadData)))
1294         pos += 4
1295         // field[1] m.ThreadData
1296         for j1 := 0; j1 < len(m.ThreadData); j1++ {
1297                 var v1 ThreadData
1298                 if j1 < len(m.ThreadData) {
1299                         v1 = m.ThreadData[j1]
1300                 }
1301                 // field[2] v1.ID
1302                 o.PutUint32(buf[pos:pos+4], uint32(v1.ID))
1303                 pos += 4
1304                 // field[2] v1.Name
1305                 copy(buf[pos:pos+64], v1.Name)
1306                 pos += 64
1307                 // field[2] v1.Type
1308                 copy(buf[pos:pos+64], v1.Type)
1309                 pos += 64
1310                 // field[2] v1.PID
1311                 o.PutUint32(buf[pos:pos+4], uint32(v1.PID))
1312                 pos += 4
1313                 // field[2] v1.CPUID
1314                 o.PutUint32(buf[pos:pos+4], uint32(v1.CPUID))
1315                 pos += 4
1316                 // field[2] v1.Core
1317                 o.PutUint32(buf[pos:pos+4], uint32(v1.Core))
1318                 pos += 4
1319                 // field[2] v1.CPUSocket
1320                 o.PutUint32(buf[pos:pos+4], uint32(v1.CPUSocket))
1321                 pos += 4
1322         }
1323         return buf, nil
1324 }
1325 func (m *ShowThreadsReply) Unmarshal(tmp []byte) error {
1326         o := binary.BigEndian
1327         _ = o
1328         pos := 0
1329         _ = pos
1330         // field[1] m.Retval
1331         m.Retval = int32(o.Uint32(tmp[pos : pos+4]))
1332         pos += 4
1333         // field[1] m.Count
1334         m.Count = uint32(o.Uint32(tmp[pos : pos+4]))
1335         pos += 4
1336         // field[1] m.ThreadData
1337         m.ThreadData = make([]ThreadData, int(m.Count))
1338         for j1 := 0; j1 < int(m.Count); j1++ {
1339                 // field[2] m.ThreadData[j1].ID
1340                 m.ThreadData[j1].ID = uint32(o.Uint32(tmp[pos : pos+4]))
1341                 pos += 4
1342                 // field[2] m.ThreadData[j1].Name
1343                 {
1344                         nul := bytes.Index(tmp[pos:pos+64], []byte{0x00})
1345                         m.ThreadData[j1].Name = codec.DecodeString(tmp[pos : pos+nul])
1346                         pos += 64
1347                 }
1348                 // field[2] m.ThreadData[j1].Type
1349                 {
1350                         nul := bytes.Index(tmp[pos:pos+64], []byte{0x00})
1351                         m.ThreadData[j1].Type = codec.DecodeString(tmp[pos : pos+nul])
1352                         pos += 64
1353                 }
1354                 // field[2] m.ThreadData[j1].PID
1355                 m.ThreadData[j1].PID = uint32(o.Uint32(tmp[pos : pos+4]))
1356                 pos += 4
1357                 // field[2] m.ThreadData[j1].CPUID
1358                 m.ThreadData[j1].CPUID = uint32(o.Uint32(tmp[pos : pos+4]))
1359                 pos += 4
1360                 // field[2] m.ThreadData[j1].Core
1361                 m.ThreadData[j1].Core = uint32(o.Uint32(tmp[pos : pos+4]))
1362                 pos += 4
1363                 // field[2] m.ThreadData[j1].CPUSocket
1364                 m.ThreadData[j1].CPUSocket = uint32(o.Uint32(tmp[pos : pos+4]))
1365                 pos += 4
1366         }
1367         return nil
1368 }
1369
1370 // ShowVersion represents VPP binary API message 'show_version'.
1371 type ShowVersion struct{}
1372
1373 func (m *ShowVersion) Reset()                        { *m = ShowVersion{} }
1374 func (*ShowVersion) GetMessageName() string          { return "show_version" }
1375 func (*ShowVersion) GetCrcString() string            { return "51077d14" }
1376 func (*ShowVersion) GetMessageType() api.MessageType { return api.RequestMessage }
1377
1378 func (m *ShowVersion) Size() int {
1379         if m == nil {
1380                 return 0
1381         }
1382         var size int
1383         return size
1384 }
1385 func (m *ShowVersion) Marshal(b []byte) ([]byte, error) {
1386         o := binary.BigEndian
1387         _ = o
1388         pos := 0
1389         _ = pos
1390         var buf []byte
1391         if b == nil {
1392                 buf = make([]byte, m.Size())
1393         } else {
1394                 buf = b
1395         }
1396         return buf, nil
1397 }
1398 func (m *ShowVersion) Unmarshal(tmp []byte) error {
1399         o := binary.BigEndian
1400         _ = o
1401         pos := 0
1402         _ = pos
1403         return nil
1404 }
1405
1406 // ShowVersionReply represents VPP binary API message 'show_version_reply'.
1407 type ShowVersionReply struct {
1408         Retval         int32  `binapi:"i32,name=retval" json:"retval,omitempty"`
1409         Program        string `binapi:"string[32],name=program" json:"program,omitempty" struc:"[32]byte"`
1410         Version        string `binapi:"string[32],name=version" json:"version,omitempty" struc:"[32]byte"`
1411         BuildDate      string `binapi:"string[32],name=build_date" json:"build_date,omitempty" struc:"[32]byte"`
1412         BuildDirectory string `binapi:"string[256],name=build_directory" json:"build_directory,omitempty" struc:"[256]byte"`
1413 }
1414
1415 func (m *ShowVersionReply) Reset()                        { *m = ShowVersionReply{} }
1416 func (*ShowVersionReply) GetMessageName() string          { return "show_version_reply" }
1417 func (*ShowVersionReply) GetCrcString() string            { return "c919bde1" }
1418 func (*ShowVersionReply) GetMessageType() api.MessageType { return api.ReplyMessage }
1419
1420 func (m *ShowVersionReply) Size() int {
1421         if m == nil {
1422                 return 0
1423         }
1424         var size int
1425         // field[1] m.Retval
1426         size += 4
1427         // field[1] m.Program
1428         size += 32
1429         // field[1] m.Version
1430         size += 32
1431         // field[1] m.BuildDate
1432         size += 32
1433         // field[1] m.BuildDirectory
1434         size += 256
1435         return size
1436 }
1437 func (m *ShowVersionReply) Marshal(b []byte) ([]byte, error) {
1438         o := binary.BigEndian
1439         _ = o
1440         pos := 0
1441         _ = pos
1442         var buf []byte
1443         if b == nil {
1444                 buf = make([]byte, m.Size())
1445         } else {
1446                 buf = b
1447         }
1448         // field[1] m.Retval
1449         o.PutUint32(buf[pos:pos+4], uint32(m.Retval))
1450         pos += 4
1451         // field[1] m.Program
1452         copy(buf[pos:pos+32], m.Program)
1453         pos += 32
1454         // field[1] m.Version
1455         copy(buf[pos:pos+32], m.Version)
1456         pos += 32
1457         // field[1] m.BuildDate
1458         copy(buf[pos:pos+32], m.BuildDate)
1459         pos += 32
1460         // field[1] m.BuildDirectory
1461         copy(buf[pos:pos+256], m.BuildDirectory)
1462         pos += 256
1463         return buf, nil
1464 }
1465 func (m *ShowVersionReply) Unmarshal(tmp []byte) error {
1466         o := binary.BigEndian
1467         _ = o
1468         pos := 0
1469         _ = pos
1470         // field[1] m.Retval
1471         m.Retval = int32(o.Uint32(tmp[pos : pos+4]))
1472         pos += 4
1473         // field[1] m.Program
1474         {
1475                 nul := bytes.Index(tmp[pos:pos+32], []byte{0x00})
1476                 m.Program = codec.DecodeString(tmp[pos : pos+nul])
1477                 pos += 32
1478         }
1479         // field[1] m.Version
1480         {
1481                 nul := bytes.Index(tmp[pos:pos+32], []byte{0x00})
1482                 m.Version = codec.DecodeString(tmp[pos : pos+nul])
1483                 pos += 32
1484         }
1485         // field[1] m.BuildDate
1486         {
1487                 nul := bytes.Index(tmp[pos:pos+32], []byte{0x00})
1488                 m.BuildDate = codec.DecodeString(tmp[pos : pos+nul])
1489                 pos += 32
1490         }
1491         // field[1] m.BuildDirectory
1492         {
1493                 nul := bytes.Index(tmp[pos:pos+256], []byte{0x00})
1494                 m.BuildDirectory = codec.DecodeString(tmp[pos : pos+nul])
1495                 pos += 256
1496         }
1497         return nil
1498 }
1499
1500 // ShowVpeSystemTime represents VPP binary API message 'show_vpe_system_time'.
1501 type ShowVpeSystemTime struct{}
1502
1503 func (m *ShowVpeSystemTime) Reset()                        { *m = ShowVpeSystemTime{} }
1504 func (*ShowVpeSystemTime) GetMessageName() string          { return "show_vpe_system_time" }
1505 func (*ShowVpeSystemTime) GetCrcString() string            { return "51077d14" }
1506 func (*ShowVpeSystemTime) GetMessageType() api.MessageType { return api.RequestMessage }
1507
1508 func (m *ShowVpeSystemTime) Size() int {
1509         if m == nil {
1510                 return 0
1511         }
1512         var size int
1513         return size
1514 }
1515 func (m *ShowVpeSystemTime) Marshal(b []byte) ([]byte, error) {
1516         o := binary.BigEndian
1517         _ = o
1518         pos := 0
1519         _ = pos
1520         var buf []byte
1521         if b == nil {
1522                 buf = make([]byte, m.Size())
1523         } else {
1524                 buf = b
1525         }
1526         return buf, nil
1527 }
1528 func (m *ShowVpeSystemTime) Unmarshal(tmp []byte) error {
1529         o := binary.BigEndian
1530         _ = o
1531         pos := 0
1532         _ = pos
1533         return nil
1534 }
1535
1536 // ShowVpeSystemTimeReply represents VPP binary API message 'show_vpe_system_time_reply'.
1537 type ShowVpeSystemTimeReply struct {
1538         Retval        int32     `binapi:"i32,name=retval" json:"retval,omitempty"`
1539         VpeSystemTime Timestamp `binapi:"timestamp,name=vpe_system_time" json:"vpe_system_time,omitempty"`
1540 }
1541
1542 func (m *ShowVpeSystemTimeReply) Reset()                        { *m = ShowVpeSystemTimeReply{} }
1543 func (*ShowVpeSystemTimeReply) GetMessageName() string          { return "show_vpe_system_time_reply" }
1544 func (*ShowVpeSystemTimeReply) GetCrcString() string            { return "7ffd8193" }
1545 func (*ShowVpeSystemTimeReply) GetMessageType() api.MessageType { return api.ReplyMessage }
1546
1547 func (m *ShowVpeSystemTimeReply) Size() int {
1548         if m == nil {
1549                 return 0
1550         }
1551         var size int
1552         // field[1] m.Retval
1553         size += 4
1554         // field[1] m.VpeSystemTime
1555         size += 8
1556         return size
1557 }
1558 func (m *ShowVpeSystemTimeReply) Marshal(b []byte) ([]byte, error) {
1559         o := binary.BigEndian
1560         _ = o
1561         pos := 0
1562         _ = pos
1563         var buf []byte
1564         if b == nil {
1565                 buf = make([]byte, m.Size())
1566         } else {
1567                 buf = b
1568         }
1569         // field[1] m.Retval
1570         o.PutUint32(buf[pos:pos+4], uint32(m.Retval))
1571         pos += 4
1572         // field[1] m.VpeSystemTime
1573         o.PutUint64(buf[pos:pos+8], math.Float64bits(float64(m.VpeSystemTime)))
1574         pos += 8
1575         return buf, nil
1576 }
1577 func (m *ShowVpeSystemTimeReply) Unmarshal(tmp []byte) error {
1578         o := binary.BigEndian
1579         _ = o
1580         pos := 0
1581         _ = pos
1582         // field[1] m.Retval
1583         m.Retval = int32(o.Uint32(tmp[pos : pos+4]))
1584         pos += 4
1585         // field[1] m.VpeSystemTime
1586         m.VpeSystemTime = Timestamp(math.Float64frombits(o.Uint64(tmp[pos : pos+8])))
1587         pos += 8
1588         return nil
1589 }
1590
1591 func init() { file_vpe_binapi_init() }
1592 func file_vpe_binapi_init() {
1593         api.RegisterMessage((*AddNodeNext)(nil), "vpe.AddNodeNext")
1594         api.RegisterMessage((*AddNodeNextReply)(nil), "vpe.AddNodeNextReply")
1595         api.RegisterMessage((*Cli)(nil), "vpe.Cli")
1596         api.RegisterMessage((*CliInband)(nil), "vpe.CliInband")
1597         api.RegisterMessage((*CliInbandReply)(nil), "vpe.CliInbandReply")
1598         api.RegisterMessage((*CliReply)(nil), "vpe.CliReply")
1599         api.RegisterMessage((*ControlPing)(nil), "vpe.ControlPing")
1600         api.RegisterMessage((*ControlPingReply)(nil), "vpe.ControlPingReply")
1601         api.RegisterMessage((*GetF64EndianValue)(nil), "vpe.GetF64EndianValue")
1602         api.RegisterMessage((*GetF64EndianValueReply)(nil), "vpe.GetF64EndianValueReply")
1603         api.RegisterMessage((*GetF64IncrementByOne)(nil), "vpe.GetF64IncrementByOne")
1604         api.RegisterMessage((*GetF64IncrementByOneReply)(nil), "vpe.GetF64IncrementByOneReply")
1605         api.RegisterMessage((*GetNextIndex)(nil), "vpe.GetNextIndex")
1606         api.RegisterMessage((*GetNextIndexReply)(nil), "vpe.GetNextIndexReply")
1607         api.RegisterMessage((*GetNodeGraph)(nil), "vpe.GetNodeGraph")
1608         api.RegisterMessage((*GetNodeGraphReply)(nil), "vpe.GetNodeGraphReply")
1609         api.RegisterMessage((*GetNodeIndex)(nil), "vpe.GetNodeIndex")
1610         api.RegisterMessage((*GetNodeIndexReply)(nil), "vpe.GetNodeIndexReply")
1611         api.RegisterMessage((*LogDetails)(nil), "vpe.LogDetails")
1612         api.RegisterMessage((*LogDump)(nil), "vpe.LogDump")
1613         api.RegisterMessage((*ShowThreads)(nil), "vpe.ShowThreads")
1614         api.RegisterMessage((*ShowThreadsReply)(nil), "vpe.ShowThreadsReply")
1615         api.RegisterMessage((*ShowVersion)(nil), "vpe.ShowVersion")
1616         api.RegisterMessage((*ShowVersionReply)(nil), "vpe.ShowVersionReply")
1617         api.RegisterMessage((*ShowVpeSystemTime)(nil), "vpe.ShowVpeSystemTime")
1618         api.RegisterMessage((*ShowVpeSystemTimeReply)(nil), "vpe.ShowVpeSystemTimeReply")
1619 }
1620
1621 // Messages returns list of all messages in this module.
1622 func AllMessages() []api.Message {
1623         return []api.Message{
1624                 (*AddNodeNext)(nil),
1625                 (*AddNodeNextReply)(nil),
1626                 (*Cli)(nil),
1627                 (*CliInband)(nil),
1628                 (*CliInbandReply)(nil),
1629                 (*CliReply)(nil),
1630                 (*ControlPing)(nil),
1631                 (*ControlPingReply)(nil),
1632                 (*GetF64EndianValue)(nil),
1633                 (*GetF64EndianValueReply)(nil),
1634                 (*GetF64IncrementByOne)(nil),
1635                 (*GetF64IncrementByOneReply)(nil),
1636                 (*GetNextIndex)(nil),
1637                 (*GetNextIndexReply)(nil),
1638                 (*GetNodeGraph)(nil),
1639                 (*GetNodeGraphReply)(nil),
1640                 (*GetNodeIndex)(nil),
1641                 (*GetNodeIndexReply)(nil),
1642                 (*LogDetails)(nil),
1643                 (*LogDump)(nil),
1644                 (*ShowThreads)(nil),
1645                 (*ShowThreadsReply)(nil),
1646                 (*ShowVersion)(nil),
1647                 (*ShowVersionReply)(nil),
1648                 (*ShowVpeSystemTime)(nil),
1649                 (*ShowVpeSystemTimeReply)(nil),
1650         }
1651 }
1652
1653 // Reference imports to suppress errors if they are not otherwise used.
1654 var _ = api.RegisterMessage
1655 var _ = codec.DecodeString
1656 var _ = bytes.NewBuffer
1657 var _ = context.Background
1658 var _ = io.Copy
1659 var _ = strconv.Itoa
1660 var _ = strings.Contains
1661 var _ = struc.Pack
1662 var _ = binary.BigEndian
1663 var _ = math.Float32bits
1664 var _ = net.ParseIP
1665 var _ = fmt.Errorf