examples/binapi/vpe/vpe.ba.go

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