binapi/vlib/vlib.ba.go

   1 // Code generated by GoVPP's binapi-generator. DO NOT EDIT.
   2 // versions:
   3 //  binapi-generator: v0.5.0
   4 //  VPP:              22.02-release
   5 // source: /usr/share/vpp/api/core/vlib.api.json
   6
   7 // Package vlib contains generated bindings for API file vlib.api.
   8 //
   9 // Contents:
  10 //   1 struct
  11 //  18 messages
  12 //
  13 package vlib
  14
  15 import (
  16         api "git.fd.io/govpp.git/api"
  17         codec "git.fd.io/govpp.git/codec"
  18 )
  19
  20 // This is a compile-time assertion to ensure that this generated file
  21 // is compatible with the GoVPP api package it is being compiled against.
  22 // A compilation error at this line likely means your copy of the
  23 // GoVPP api package needs to be updated.
  24 const _ = api.GoVppAPIPackageIsVersion2
  25
  26 const (
  27         APIFile    = "vlib"
  28         APIVersion = "1.0.0"
  29         VersionCrc = 0x9a9e84e4
  30 )
  31
  32 // ThreadData defines type 'thread_data'.
  33 type ThreadData struct {
  34         ID        uint32 `binapi:"u32,name=id" json:"id,omitempty"`
  35         Name      string `binapi:"string[64],name=name" json:"name,omitempty"`
  36         Type      string `binapi:"string[64],name=type" json:"type,omitempty"`
  37         PID       uint32 `binapi:"u32,name=pid" json:"pid,omitempty"`
  38         CPUID     uint32 `binapi:"u32,name=cpu_id" json:"cpu_id,omitempty"`
  39         Core      uint32 `binapi:"u32,name=core" json:"core,omitempty"`
  40         CPUSocket uint32 `binapi:"u32,name=cpu_socket" json:"cpu_socket,omitempty"`
  41 }
  42
  43 // AddNodeNext defines message 'add_node_next'.
  44 type AddNodeNext struct {
  45         NodeName string `binapi:"string[64],name=node_name" json:"node_name,omitempty"`
  46         NextName string `binapi:"string[64],name=next_name" json:"next_name,omitempty"`
  47 }
  48
  49 func (m *AddNodeNext) Reset()               { *m = AddNodeNext{} }
  50 func (*AddNodeNext) GetMessageName() string { return "add_node_next" }
  51 func (*AddNodeNext) GetCrcString() string   { return "2457116d" }
  52 func (*AddNodeNext) GetMessageType() api.MessageType {
  53         return api.RequestMessage
  54 }
  55
  56 func (m *AddNodeNext) Size() (size int) {
  57         if m == nil {
  58                 return 0
  59         }
  60         size += 64 // m.NodeName
  61         size += 64 // m.NextName
  62         return size
  63 }
  64 func (m *AddNodeNext) Marshal(b []byte) ([]byte, error) {
  65         if b == nil {
  66                 b = make([]byte, m.Size())
  67         }
  68         buf := codec.NewBuffer(b)
  69         buf.EncodeString(m.NodeName, 64)
  70         buf.EncodeString(m.NextName, 64)
  71         return buf.Bytes(), nil
  72 }
  73 func (m *AddNodeNext) Unmarshal(b []byte) error {
  74         buf := codec.NewBuffer(b)
  75         m.NodeName = buf.DecodeString(64)
  76         m.NextName = buf.DecodeString(64)
  77         return nil
  78 }
  79
  80 // AddNodeNextReply defines message 'add_node_next_reply'.
  81 type AddNodeNextReply struct {
  82         Retval    int32  `binapi:"i32,name=retval" json:"retval,omitempty"`
  83         NextIndex uint32 `binapi:"u32,name=next_index" json:"next_index,omitempty"`
  84 }
  85
  86 func (m *AddNodeNextReply) Reset()               { *m = AddNodeNextReply{} }
  87 func (*AddNodeNextReply) GetMessageName() string { return "add_node_next_reply" }
  88 func (*AddNodeNextReply) GetCrcString() string   { return "2ed75f32" }
  89 func (*AddNodeNextReply) GetMessageType() api.MessageType {
  90         return api.ReplyMessage
  91 }
  92
  93 func (m *AddNodeNextReply) Size() (size int) {
  94         if m == nil {
  95                 return 0
  96         }
  97         size += 4 // m.Retval
  98         size += 4 // m.NextIndex
  99         return size
 100 }
 101 func (m *AddNodeNextReply) Marshal(b []byte) ([]byte, error) {
 102         if b == nil {
 103                 b = make([]byte, m.Size())
 104         }
 105         buf := codec.NewBuffer(b)
 106         buf.EncodeInt32(m.Retval)
 107         buf.EncodeUint32(m.NextIndex)
 108         return buf.Bytes(), nil
 109 }
 110 func (m *AddNodeNextReply) Unmarshal(b []byte) error {
 111         buf := codec.NewBuffer(b)
 112         m.Retval = buf.DecodeInt32()
 113         m.NextIndex = buf.DecodeUint32()
 114         return nil
 115 }
 116
 117 // Cli defines message 'cli'.
 118 type Cli struct {
 119         CmdInShmem uint64 `binapi:"u64,name=cmd_in_shmem" json:"cmd_in_shmem,omitempty"`
 120 }
 121
 122 func (m *Cli) Reset()               { *m = Cli{} }
 123 func (*Cli) GetMessageName() string { return "cli" }
 124 func (*Cli) GetCrcString() string   { return "23bfbfff" }
 125 func (*Cli) GetMessageType() api.MessageType {
 126         return api.RequestMessage
 127 }
 128
 129 func (m *Cli) Size() (size int) {
 130         if m == nil {
 131                 return 0
 132         }
 133         size += 8 // m.CmdInShmem
 134         return size
 135 }
 136 func (m *Cli) Marshal(b []byte) ([]byte, error) {
 137         if b == nil {
 138                 b = make([]byte, m.Size())
 139         }
 140         buf := codec.NewBuffer(b)
 141         buf.EncodeUint64(m.CmdInShmem)
 142         return buf.Bytes(), nil
 143 }
 144 func (m *Cli) Unmarshal(b []byte) error {
 145         buf := codec.NewBuffer(b)
 146         m.CmdInShmem = buf.DecodeUint64()
 147         return nil
 148 }
 149
 150 // CliInband defines message 'cli_inband'.
 151 type CliInband struct {
 152         Cmd string `binapi:"string[],name=cmd" json:"cmd,omitempty"`
 153 }
 154
 155 func (m *CliInband) Reset()               { *m = CliInband{} }
 156 func (*CliInband) GetMessageName() string { return "cli_inband" }
 157 func (*CliInband) GetCrcString() string   { return "f8377302" }
 158 func (*CliInband) GetMessageType() api.MessageType {
 159         return api.RequestMessage
 160 }
 161
 162 func (m *CliInband) Size() (size int) {
 163         if m == nil {
 164                 return 0
 165         }
 166         size += 4 + len(m.Cmd) // m.Cmd
 167         return size
 168 }
 169 func (m *CliInband) Marshal(b []byte) ([]byte, error) {
 170         if b == nil {
 171                 b = make([]byte, m.Size())
 172         }
 173         buf := codec.NewBuffer(b)
 174         buf.EncodeString(m.Cmd, 0)
 175         return buf.Bytes(), nil
 176 }
 177 func (m *CliInband) Unmarshal(b []byte) error {
 178         buf := codec.NewBuffer(b)
 179         m.Cmd = buf.DecodeString(0)
 180         return nil
 181 }
 182
 183 // CliInbandReply defines message 'cli_inband_reply'.
 184 type CliInbandReply struct {
 185         Retval int32  `binapi:"i32,name=retval" json:"retval,omitempty"`
 186         Reply  string `binapi:"string[],name=reply" json:"reply,omitempty"`
 187 }
 188
 189 func (m *CliInbandReply) Reset()               { *m = CliInbandReply{} }
 190 func (*CliInbandReply) GetMessageName() string { return "cli_inband_reply" }
 191 func (*CliInbandReply) GetCrcString() string   { return "05879051" }
 192 func (*CliInbandReply) GetMessageType() api.MessageType {
 193         return api.ReplyMessage
 194 }
 195
 196 func (m *CliInbandReply) Size() (size int) {
 197         if m == nil {
 198                 return 0
 199         }
 200         size += 4                // m.Retval
 201         size += 4 + len(m.Reply) // m.Reply
 202         return size
 203 }
 204 func (m *CliInbandReply) Marshal(b []byte) ([]byte, error) {
 205         if b == nil {
 206                 b = make([]byte, m.Size())
 207         }
 208         buf := codec.NewBuffer(b)
 209         buf.EncodeInt32(m.Retval)
 210         buf.EncodeString(m.Reply, 0)
 211         return buf.Bytes(), nil
 212 }
 213 func (m *CliInbandReply) Unmarshal(b []byte) error {
 214         buf := codec.NewBuffer(b)
 215         m.Retval = buf.DecodeInt32()
 216         m.Reply = buf.DecodeString(0)
 217         return nil
 218 }
 219
 220 // CliReply defines message 'cli_reply'.
 221 type CliReply struct {
 222         Retval       int32  `binapi:"i32,name=retval" json:"retval,omitempty"`
 223         ReplyInShmem uint64 `binapi:"u64,name=reply_in_shmem" json:"reply_in_shmem,omitempty"`
 224 }
 225
 226 func (m *CliReply) Reset()               { *m = CliReply{} }
 227 func (*CliReply) GetMessageName() string { return "cli_reply" }
 228 func (*CliReply) GetCrcString() string   { return "06d68297" }
 229 func (*CliReply) GetMessageType() api.MessageType {
 230         return api.ReplyMessage
 231 }
 232
 233 func (m *CliReply) Size() (size int) {
 234         if m == nil {
 235                 return 0
 236         }
 237         size += 4 // m.Retval
 238         size += 8 // m.ReplyInShmem
 239         return size
 240 }
 241 func (m *CliReply) Marshal(b []byte) ([]byte, error) {
 242         if b == nil {
 243                 b = make([]byte, m.Size())
 244         }
 245         buf := codec.NewBuffer(b)
 246         buf.EncodeInt32(m.Retval)
 247         buf.EncodeUint64(m.ReplyInShmem)
 248         return buf.Bytes(), nil
 249 }
 250 func (m *CliReply) Unmarshal(b []byte) error {
 251         buf := codec.NewBuffer(b)
 252         m.Retval = buf.DecodeInt32()
 253         m.ReplyInShmem = buf.DecodeUint64()
 254         return nil
 255 }
 256
 257 // GetF64EndianValue defines message 'get_f64_endian_value'.
 258 type GetF64EndianValue struct {
 259         F64One float64 `binapi:"f64,name=f64_one,default=1" json:"f64_one,omitempty"`
 260 }
 261
 262 func (m *GetF64EndianValue) Reset()               { *m = GetF64EndianValue{} }
 263 func (*GetF64EndianValue) GetMessageName() string { return "get_f64_endian_value" }
 264 func (*GetF64EndianValue) GetCrcString() string   { return "809fcd44" }
 265 func (*GetF64EndianValue) GetMessageType() api.MessageType {
 266         return api.RequestMessage
 267 }
 268
 269 func (m *GetF64EndianValue) Size() (size int) {
 270         if m == nil {
 271                 return 0
 272         }
 273         size += 8 // m.F64One
 274         return size
 275 }
 276 func (m *GetF64EndianValue) Marshal(b []byte) ([]byte, error) {
 277         if b == nil {
 278                 b = make([]byte, m.Size())
 279         }
 280         buf := codec.NewBuffer(b)
 281         buf.EncodeFloat64(m.F64One)
 282         return buf.Bytes(), nil
 283 }
 284 func (m *GetF64EndianValue) Unmarshal(b []byte) error {
 285         buf := codec.NewBuffer(b)
 286         m.F64One = buf.DecodeFloat64()
 287         return nil
 288 }
 289
 290 // GetF64EndianValueReply defines message 'get_f64_endian_value_reply'.
 291 type GetF64EndianValueReply struct {
 292         Retval       uint32  `binapi:"u32,name=retval" json:"retval,omitempty"`
 293         F64OneResult float64 `binapi:"f64,name=f64_one_result" json:"f64_one_result,omitempty"`
 294 }
 295
 296 func (m *GetF64EndianValueReply) Reset()               { *m = GetF64EndianValueReply{} }
 297 func (*GetF64EndianValueReply) GetMessageName() string { return "get_f64_endian_value_reply" }
 298 func (*GetF64EndianValueReply) GetCrcString() string   { return "7e02e404" }
 299 func (*GetF64EndianValueReply) GetMessageType() api.MessageType {
 300         return api.ReplyMessage
 301 }
 302
 303 func (m *GetF64EndianValueReply) Size() (size int) {
 304         if m == nil {
 305                 return 0
 306         }
 307         size += 4 // m.Retval
 308         size += 8 // m.F64OneResult
 309         return size
 310 }
 311 func (m *GetF64EndianValueReply) Marshal(b []byte) ([]byte, error) {
 312         if b == nil {
 313                 b = make([]byte, m.Size())
 314         }
 315         buf := codec.NewBuffer(b)
 316         buf.EncodeUint32(m.Retval)
 317         buf.EncodeFloat64(m.F64OneResult)
 318         return buf.Bytes(), nil
 319 }
 320 func (m *GetF64EndianValueReply) Unmarshal(b []byte) error {
 321         buf := codec.NewBuffer(b)
 322         m.Retval = buf.DecodeUint32()
 323         m.F64OneResult = buf.DecodeFloat64()
 324         return nil
 325 }
 326
 327 // GetF64IncrementByOne defines message 'get_f64_increment_by_one'.
 328 type GetF64IncrementByOne struct {
 329         F64Value float64 `binapi:"f64,name=f64_value,default=1" json:"f64_value,omitempty"`
 330 }
 331
 332 func (m *GetF64IncrementByOne) Reset()               { *m = GetF64IncrementByOne{} }
 333 func (*GetF64IncrementByOne) GetMessageName() string { return "get_f64_increment_by_one" }
 334 func (*GetF64IncrementByOne) GetCrcString() string   { return "b64f027e" }
 335 func (*GetF64IncrementByOne) GetMessageType() api.MessageType {
 336         return api.RequestMessage
 337 }
 338
 339 func (m *GetF64IncrementByOne) Size() (size int) {
 340         if m == nil {
 341                 return 0
 342         }
 343         size += 8 // m.F64Value
 344         return size
 345 }
 346 func (m *GetF64IncrementByOne) Marshal(b []byte) ([]byte, error) {
 347         if b == nil {
 348                 b = make([]byte, m.Size())
 349         }
 350         buf := codec.NewBuffer(b)
 351         buf.EncodeFloat64(m.F64Value)
 352         return buf.Bytes(), nil
 353 }
 354 func (m *GetF64IncrementByOne) Unmarshal(b []byte) error {
 355         buf := codec.NewBuffer(b)
 356         m.F64Value = buf.DecodeFloat64()
 357         return nil
 358 }
 359
 360 // GetF64IncrementByOneReply defines message 'get_f64_increment_by_one_reply'.
 361 type GetF64IncrementByOneReply struct {
 362         Retval   uint32  `binapi:"u32,name=retval" json:"retval,omitempty"`
 363         F64Value float64 `binapi:"f64,name=f64_value" json:"f64_value,omitempty"`
 364 }
 365
 366 func (m *GetF64IncrementByOneReply) Reset()               { *m = GetF64IncrementByOneReply{} }
 367 func (*GetF64IncrementByOneReply) GetMessageName() string { return "get_f64_increment_by_one_reply" }
 368 func (*GetF64IncrementByOneReply) GetCrcString() string   { return "d25dbaa3" }
 369 func (*GetF64IncrementByOneReply) GetMessageType() api.MessageType {
 370         return api.ReplyMessage
 371 }
 372
 373 func (m *GetF64IncrementByOneReply) Size() (size int) {
 374         if m == nil {
 375                 return 0
 376         }
 377         size += 4 // m.Retval
 378         size += 8 // m.F64Value
 379         return size
 380 }
 381 func (m *GetF64IncrementByOneReply) Marshal(b []byte) ([]byte, error) {
 382         if b == nil {
 383                 b = make([]byte, m.Size())
 384         }
 385         buf := codec.NewBuffer(b)
 386         buf.EncodeUint32(m.Retval)
 387         buf.EncodeFloat64(m.F64Value)
 388         return buf.Bytes(), nil
 389 }
 390 func (m *GetF64IncrementByOneReply) Unmarshal(b []byte) error {
 391         buf := codec.NewBuffer(b)
 392         m.Retval = buf.DecodeUint32()
 393         m.F64Value = buf.DecodeFloat64()
 394         return nil
 395 }
 396
 397 // GetNextIndex defines message 'get_next_index'.
 398 type GetNextIndex struct {
 399         NodeName string `binapi:"string[64],name=node_name" json:"node_name,omitempty"`
 400         NextName string `binapi:"string[64],name=next_name" json:"next_name,omitempty"`
 401 }
 402
 403 func (m *GetNextIndex) Reset()               { *m = GetNextIndex{} }
 404 func (*GetNextIndex) GetMessageName() string { return "get_next_index" }
 405 func (*GetNextIndex) GetCrcString() string   { return "2457116d" }
 406 func (*GetNextIndex) GetMessageType() api.MessageType {
 407         return api.RequestMessage
 408 }
 409
 410 func (m *GetNextIndex) Size() (size int) {
 411         if m == nil {
 412                 return 0
 413         }
 414         size += 64 // m.NodeName
 415         size += 64 // m.NextName
 416         return size
 417 }
 418 func (m *GetNextIndex) Marshal(b []byte) ([]byte, error) {
 419         if b == nil {
 420                 b = make([]byte, m.Size())
 421         }
 422         buf := codec.NewBuffer(b)
 423         buf.EncodeString(m.NodeName, 64)
 424         buf.EncodeString(m.NextName, 64)
 425         return buf.Bytes(), nil
 426 }
 427 func (m *GetNextIndex) Unmarshal(b []byte) error {
 428         buf := codec.NewBuffer(b)
 429         m.NodeName = buf.DecodeString(64)
 430         m.NextName = buf.DecodeString(64)
 431         return nil
 432 }
 433
 434 // GetNextIndexReply defines message 'get_next_index_reply'.
 435 type GetNextIndexReply struct {
 436         Retval    int32  `binapi:"i32,name=retval" json:"retval,omitempty"`
 437         NextIndex uint32 `binapi:"u32,name=next_index" json:"next_index,omitempty"`
 438 }
 439
 440 func (m *GetNextIndexReply) Reset()               { *m = GetNextIndexReply{} }
 441 func (*GetNextIndexReply) GetMessageName() string { return "get_next_index_reply" }
 442 func (*GetNextIndexReply) GetCrcString() string   { return "2ed75f32" }
 443 func (*GetNextIndexReply) GetMessageType() api.MessageType {
 444         return api.ReplyMessage
 445 }
 446
 447 func (m *GetNextIndexReply) Size() (size int) {
 448         if m == nil {
 449                 return 0
 450         }
 451         size += 4 // m.Retval
 452         size += 4 // m.NextIndex
 453         return size
 454 }
 455 func (m *GetNextIndexReply) Marshal(b []byte) ([]byte, error) {
 456         if b == nil {
 457                 b = make([]byte, m.Size())
 458         }
 459         buf := codec.NewBuffer(b)
 460         buf.EncodeInt32(m.Retval)
 461         buf.EncodeUint32(m.NextIndex)
 462         return buf.Bytes(), nil
 463 }
 464 func (m *GetNextIndexReply) Unmarshal(b []byte) error {
 465         buf := codec.NewBuffer(b)
 466         m.Retval = buf.DecodeInt32()
 467         m.NextIndex = buf.DecodeUint32()
 468         return nil
 469 }
 470
 471 // GetNodeGraph defines message 'get_node_graph'.
 472 type GetNodeGraph struct{}
 473
 474 func (m *GetNodeGraph) Reset()               { *m = GetNodeGraph{} }
 475 func (*GetNodeGraph) GetMessageName() string { return "get_node_graph" }
 476 func (*GetNodeGraph) GetCrcString() string   { return "51077d14" }
 477 func (*GetNodeGraph) GetMessageType() api.MessageType {
 478         return api.RequestMessage
 479 }
 480
 481 func (m *GetNodeGraph) Size() (size int) {
 482         if m == nil {
 483                 return 0
 484         }
 485         return size
 486 }
 487 func (m *GetNodeGraph) Marshal(b []byte) ([]byte, error) {
 488         if b == nil {
 489                 b = make([]byte, m.Size())
 490         }
 491         buf := codec.NewBuffer(b)
 492         return buf.Bytes(), nil
 493 }
 494 func (m *GetNodeGraph) Unmarshal(b []byte) error {
 495         return nil
 496 }
 497
 498 // GetNodeGraphReply defines message 'get_node_graph_reply'.
 499 type GetNodeGraphReply struct {
 500         Retval       int32  `binapi:"i32,name=retval" json:"retval,omitempty"`
 501         ReplyInShmem uint64 `binapi:"u64,name=reply_in_shmem" json:"reply_in_shmem,omitempty"`
 502 }
 503
 504 func (m *GetNodeGraphReply) Reset()               { *m = GetNodeGraphReply{} }
 505 func (*GetNodeGraphReply) GetMessageName() string { return "get_node_graph_reply" }
 506 func (*GetNodeGraphReply) GetCrcString() string   { return "06d68297" }
 507 func (*GetNodeGraphReply) GetMessageType() api.MessageType {
 508         return api.ReplyMessage
 509 }
 510
 511 func (m *GetNodeGraphReply) Size() (size int) {
 512         if m == nil {
 513                 return 0
 514         }
 515         size += 4 // m.Retval
 516         size += 8 // m.ReplyInShmem
 517         return size
 518 }
 519 func (m *GetNodeGraphReply) Marshal(b []byte) ([]byte, error) {
 520         if b == nil {
 521                 b = make([]byte, m.Size())
 522         }
 523         buf := codec.NewBuffer(b)
 524         buf.EncodeInt32(m.Retval)
 525         buf.EncodeUint64(m.ReplyInShmem)
 526         return buf.Bytes(), nil
 527 }
 528 func (m *GetNodeGraphReply) Unmarshal(b []byte) error {
 529         buf := codec.NewBuffer(b)
 530         m.Retval = buf.DecodeInt32()
 531         m.ReplyInShmem = buf.DecodeUint64()
 532         return nil
 533 }
 534
 535 // GetNodeIndex defines message 'get_node_index'.
 536 type GetNodeIndex struct {
 537         NodeName string `binapi:"string[64],name=node_name" json:"node_name,omitempty"`
 538 }
 539
 540 func (m *GetNodeIndex) Reset()               { *m = GetNodeIndex{} }
 541 func (*GetNodeIndex) GetMessageName() string { return "get_node_index" }
 542 func (*GetNodeIndex) GetCrcString() string   { return "f1984c64" }
 543 func (*GetNodeIndex) GetMessageType() api.MessageType {
 544         return api.RequestMessage
 545 }
 546
 547 func (m *GetNodeIndex) Size() (size int) {
 548         if m == nil {
 549                 return 0
 550         }
 551         size += 64 // m.NodeName
 552         return size
 553 }
 554 func (m *GetNodeIndex) Marshal(b []byte) ([]byte, error) {
 555         if b == nil {
 556                 b = make([]byte, m.Size())
 557         }
 558         buf := codec.NewBuffer(b)
 559         buf.EncodeString(m.NodeName, 64)
 560         return buf.Bytes(), nil
 561 }
 562 func (m *GetNodeIndex) Unmarshal(b []byte) error {
 563         buf := codec.NewBuffer(b)
 564         m.NodeName = buf.DecodeString(64)
 565         return nil
 566 }
 567
 568 // GetNodeIndexReply defines message 'get_node_index_reply'.
 569 type GetNodeIndexReply struct {
 570         Retval    int32  `binapi:"i32,name=retval" json:"retval,omitempty"`
 571         NodeIndex uint32 `binapi:"u32,name=node_index" json:"node_index,omitempty"`
 572 }
 573
 574 func (m *GetNodeIndexReply) Reset()               { *m = GetNodeIndexReply{} }
 575 func (*GetNodeIndexReply) GetMessageName() string { return "get_node_index_reply" }
 576 func (*GetNodeIndexReply) GetCrcString() string   { return "a8600b89" }
 577 func (*GetNodeIndexReply) GetMessageType() api.MessageType {
 578         return api.ReplyMessage
 579 }
 580
 581 func (m *GetNodeIndexReply) Size() (size int) {
 582         if m == nil {
 583                 return 0
 584         }
 585         size += 4 // m.Retval
 586         size += 4 // m.NodeIndex
 587         return size
 588 }
 589 func (m *GetNodeIndexReply) Marshal(b []byte) ([]byte, error) {
 590         if b == nil {
 591                 b = make([]byte, m.Size())
 592         }
 593         buf := codec.NewBuffer(b)
 594         buf.EncodeInt32(m.Retval)
 595         buf.EncodeUint32(m.NodeIndex)
 596         return buf.Bytes(), nil
 597 }
 598 func (m *GetNodeIndexReply) Unmarshal(b []byte) error {
 599         buf := codec.NewBuffer(b)
 600         m.Retval = buf.DecodeInt32()
 601         m.NodeIndex = buf.DecodeUint32()
 602         return nil
 603 }
 604
 605 // ShowThreads defines message 'show_threads'.
 606 type ShowThreads struct{}
 607
 608 func (m *ShowThreads) Reset()               { *m = ShowThreads{} }
 609 func (*ShowThreads) GetMessageName() string { return "show_threads" }
 610 func (*ShowThreads) GetCrcString() string   { return "51077d14" }
 611 func (*ShowThreads) GetMessageType() api.MessageType {
 612         return api.RequestMessage
 613 }
 614
 615 func (m *ShowThreads) Size() (size int) {
 616         if m == nil {
 617                 return 0
 618         }
 619         return size
 620 }
 621 func (m *ShowThreads) Marshal(b []byte) ([]byte, error) {
 622         if b == nil {
 623                 b = make([]byte, m.Size())
 624         }
 625         buf := codec.NewBuffer(b)
 626         return buf.Bytes(), nil
 627 }
 628 func (m *ShowThreads) Unmarshal(b []byte) error {
 629         return nil
 630 }
 631
 632 // ShowThreadsReply defines message 'show_threads_reply'.
 633 type ShowThreadsReply struct {
 634         Retval     int32        `binapi:"i32,name=retval" json:"retval,omitempty"`
 635         Count      uint32       `binapi:"u32,name=count" json:"-"`
 636         ThreadData []ThreadData `binapi:"thread_data[count],name=thread_data" json:"thread_data,omitempty"`
 637 }
 638
 639 func (m *ShowThreadsReply) Reset()               { *m = ShowThreadsReply{} }
 640 func (*ShowThreadsReply) GetMessageName() string { return "show_threads_reply" }
 641 func (*ShowThreadsReply) GetCrcString() string   { return "efd78e83" }
 642 func (*ShowThreadsReply) GetMessageType() api.MessageType {
 643         return api.ReplyMessage
 644 }
 645
 646 func (m *ShowThreadsReply) Size() (size int) {
 647         if m == nil {
 648                 return 0
 649         }
 650         size += 4 // m.Retval
 651         size += 4 // m.Count
 652         for j1 := 0; j1 < len(m.ThreadData); j1++ {
 653                 var s1 ThreadData
 654                 _ = s1
 655                 if j1 < len(m.ThreadData) {
 656                         s1 = m.ThreadData[j1]
 657                 }
 658                 size += 4  // s1.ID
 659                 size += 64 // s1.Name
 660                 size += 64 // s1.Type
 661                 size += 4  // s1.PID
 662                 size += 4  // s1.CPUID
 663                 size += 4  // s1.Core
 664                 size += 4  // s1.CPUSocket
 665         }
 666         return size
 667 }
 668 func (m *ShowThreadsReply) Marshal(b []byte) ([]byte, error) {
 669         if b == nil {
 670                 b = make([]byte, m.Size())
 671         }
 672         buf := codec.NewBuffer(b)
 673         buf.EncodeInt32(m.Retval)
 674         buf.EncodeUint32(uint32(len(m.ThreadData)))
 675         for j0 := 0; j0 < len(m.ThreadData); j0++ {
 676                 var v0 ThreadData // ThreadData
 677                 if j0 < len(m.ThreadData) {
 678                         v0 = m.ThreadData[j0]
 679                 }
 680                 buf.EncodeUint32(v0.ID)
 681                 buf.EncodeString(v0.Name, 64)
 682                 buf.EncodeString(v0.Type, 64)
 683                 buf.EncodeUint32(v0.PID)
 684                 buf.EncodeUint32(v0.CPUID)
 685                 buf.EncodeUint32(v0.Core)
 686                 buf.EncodeUint32(v0.CPUSocket)
 687         }
 688         return buf.Bytes(), nil
 689 }
 690 func (m *ShowThreadsReply) Unmarshal(b []byte) error {
 691         buf := codec.NewBuffer(b)
 692         m.Retval = buf.DecodeInt32()
 693         m.Count = buf.DecodeUint32()
 694         m.ThreadData = make([]ThreadData, m.Count)
 695         for j0 := 0; j0 < len(m.ThreadData); j0++ {
 696                 m.ThreadData[j0].ID = buf.DecodeUint32()
 697                 m.ThreadData[j0].Name = buf.DecodeString(64)
 698                 m.ThreadData[j0].Type = buf.DecodeString(64)
 699                 m.ThreadData[j0].PID = buf.DecodeUint32()
 700                 m.ThreadData[j0].CPUID = buf.DecodeUint32()
 701                 m.ThreadData[j0].Core = buf.DecodeUint32()
 702                 m.ThreadData[j0].CPUSocket = buf.DecodeUint32()
 703         }
 704         return nil
 705 }
 706
 707 func init() { file_vlib_binapi_init() }
 708 func file_vlib_binapi_init() {
 709         api.RegisterMessage((*AddNodeNext)(nil), "add_node_next_2457116d")
 710         api.RegisterMessage((*AddNodeNextReply)(nil), "add_node_next_reply_2ed75f32")
 711         api.RegisterMessage((*Cli)(nil), "cli_23bfbfff")
 712         api.RegisterMessage((*CliInband)(nil), "cli_inband_f8377302")
 713         api.RegisterMessage((*CliInbandReply)(nil), "cli_inband_reply_05879051")
 714         api.RegisterMessage((*CliReply)(nil), "cli_reply_06d68297")
 715         api.RegisterMessage((*GetF64EndianValue)(nil), "get_f64_endian_value_809fcd44")
 716         api.RegisterMessage((*GetF64EndianValueReply)(nil), "get_f64_endian_value_reply_7e02e404")
 717         api.RegisterMessage((*GetF64IncrementByOne)(nil), "get_f64_increment_by_one_b64f027e")
 718         api.RegisterMessage((*GetF64IncrementByOneReply)(nil), "get_f64_increment_by_one_reply_d25dbaa3")
 719         api.RegisterMessage((*GetNextIndex)(nil), "get_next_index_2457116d")
 720         api.RegisterMessage((*GetNextIndexReply)(nil), "get_next_index_reply_2ed75f32")
 721         api.RegisterMessage((*GetNodeGraph)(nil), "get_node_graph_51077d14")
 722         api.RegisterMessage((*GetNodeGraphReply)(nil), "get_node_graph_reply_06d68297")
 723         api.RegisterMessage((*GetNodeIndex)(nil), "get_node_index_f1984c64")
 724         api.RegisterMessage((*GetNodeIndexReply)(nil), "get_node_index_reply_a8600b89")
 725         api.RegisterMessage((*ShowThreads)(nil), "show_threads_51077d14")
 726         api.RegisterMessage((*ShowThreadsReply)(nil), "show_threads_reply_efd78e83")
 727 }
 728
 729 // Messages returns list of all messages in this module.
 730 func AllMessages() []api.Message {
 731         return []api.Message{
 732                 (*AddNodeNext)(nil),
 733                 (*AddNodeNextReply)(nil),
 734                 (*Cli)(nil),
 735                 (*CliInband)(nil),
 736                 (*CliInbandReply)(nil),
 737                 (*CliReply)(nil),
 738                 (*GetF64EndianValue)(nil),
 739                 (*GetF64EndianValueReply)(nil),
 740                 (*GetF64IncrementByOne)(nil),
 741                 (*GetF64IncrementByOneReply)(nil),
 742                 (*GetNextIndex)(nil),
 743                 (*GetNextIndexReply)(nil),
 744                 (*GetNodeGraph)(nil),
 745                 (*GetNodeGraphReply)(nil),
 746                 (*GetNodeIndex)(nil),
 747                 (*GetNodeIndexReply)(nil),
 748                 (*ShowThreads)(nil),
 749                 (*ShowThreadsReply)(nil),
 750         }
 751 }