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