// Code generated by GoVPP's binapi-generator. DO NOT EDIT.
// versions:
//  binapi-generator: v0.4.0-dev
//  VPP:              20.05-release
// source: /usr/share/vpp/api/core/vpe.api.json

/*
Package vpe contains generated code for VPP API file vpe.api (1.6.1).

It consists of:
	  2 aliases
	  1 enum
	 26 messages
	  2 types
*/
package vpe

import (
	"bytes"
	"context"
	"encoding/binary"
	"fmt"
	"io"
	"math"
	"net"
	"strconv"
	"strings"

	api "git.fd.io/govpp.git/api"
	codec "git.fd.io/govpp.git/codec"
	struc "github.com/lunixbochs/struc"
)

// This is a compile-time assertion to ensure that this generated file
// is compatible with the GoVPP api package it is being compiled against.
// A compilation error at this line likely means your copy of the
// GoVPP api package needs to be updated.
const _ = api.GoVppAPIPackageIsVersion2 // please upgrade the GoVPP api package

const (
	// ModuleName is the name of this module.
	ModuleName = "vpe"
	// APIVersion is the API version of this module.
	APIVersion = "1.6.1"
	// VersionCrc is the CRC of this module.
	VersionCrc = 0xbd2c94f4
)

// LogLevel represents VPP binary API enum 'log_level'.
type LogLevel uint32

const (
	VPE_API_LOG_LEVEL_EMERG    LogLevel = 0
	VPE_API_LOG_LEVEL_ALERT    LogLevel = 1
	VPE_API_LOG_LEVEL_CRIT     LogLevel = 2
	VPE_API_LOG_LEVEL_ERR      LogLevel = 3
	VPE_API_LOG_LEVEL_WARNING  LogLevel = 4
	VPE_API_LOG_LEVEL_NOTICE   LogLevel = 5
	VPE_API_LOG_LEVEL_INFO     LogLevel = 6
	VPE_API_LOG_LEVEL_DEBUG    LogLevel = 7
	VPE_API_LOG_LEVEL_DISABLED LogLevel = 8
)

var (
	LogLevel_name = map[uint32]string{
		0: "VPE_API_LOG_LEVEL_EMERG",
		1: "VPE_API_LOG_LEVEL_ALERT",
		2: "VPE_API_LOG_LEVEL_CRIT",
		3: "VPE_API_LOG_LEVEL_ERR",
		4: "VPE_API_LOG_LEVEL_WARNING",
		5: "VPE_API_LOG_LEVEL_NOTICE",
		6: "VPE_API_LOG_LEVEL_INFO",
		7: "VPE_API_LOG_LEVEL_DEBUG",
		8: "VPE_API_LOG_LEVEL_DISABLED",
	}
	LogLevel_value = map[string]uint32{
		"VPE_API_LOG_LEVEL_EMERG":    0,
		"VPE_API_LOG_LEVEL_ALERT":    1,
		"VPE_API_LOG_LEVEL_CRIT":     2,
		"VPE_API_LOG_LEVEL_ERR":      3,
		"VPE_API_LOG_LEVEL_WARNING":  4,
		"VPE_API_LOG_LEVEL_NOTICE":   5,
		"VPE_API_LOG_LEVEL_INFO":     6,
		"VPE_API_LOG_LEVEL_DEBUG":    7,
		"VPE_API_LOG_LEVEL_DISABLED": 8,
	}
)

func (x LogLevel) String() string {
	s, ok := LogLevel_name[uint32(x)]
	if ok {
		return s
	}
	return "LogLevel(" + strconv.Itoa(int(x)) + ")"
}

// Timedelta represents VPP binary API alias 'timedelta'.
type Timedelta float64

// Timestamp represents VPP binary API alias 'timestamp'.
type Timestamp float64

// ThreadData represents VPP binary API type 'thread_data'.
type ThreadData struct {
	ID        uint32 `binapi:"u32,name=id" json:"id,omitempty"`
	Name      string `binapi:"string[64],name=name" json:"name,omitempty" struc:"[64]byte"`
	Type      string `binapi:"string[64],name=type" json:"type,omitempty" struc:"[64]byte"`
	PID       uint32 `binapi:"u32,name=pid" json:"pid,omitempty"`
	CPUID     uint32 `binapi:"u32,name=cpu_id" json:"cpu_id,omitempty"`
	Core      uint32 `binapi:"u32,name=core" json:"core,omitempty"`
	CPUSocket uint32 `binapi:"u32,name=cpu_socket" json:"cpu_socket,omitempty"`
}

func (*ThreadData) GetTypeName() string { return "thread_data" }

// Version represents VPP binary API type 'version'.
type Version struct {
	Major         uint32 `binapi:"u32,name=major" json:"major,omitempty"`
	Minor         uint32 `binapi:"u32,name=minor" json:"minor,omitempty"`
	Patch         uint32 `binapi:"u32,name=patch" json:"patch,omitempty"`
	PreRelease    []byte `binapi:"u8[17],name=pre_release" json:"pre_release,omitempty" struc:"[17]byte"`
	BuildMetadata []byte `binapi:"u8[17],name=build_metadata" json:"build_metadata,omitempty" struc:"[17]byte"`
}

func (*Version) GetTypeName() string { return "version" }

// AddNodeNext represents VPP binary API message 'add_node_next'.
type AddNodeNext struct {
	NodeName string `binapi:"string[64],name=node_name" json:"node_name,omitempty" struc:"[64]byte"`
	NextName string `binapi:"string[64],name=next_name" json:"next_name,omitempty" struc:"[64]byte"`
}

func (m *AddNodeNext) Reset()                        { *m = AddNodeNext{} }
func (*AddNodeNext) GetMessageName() string          { return "add_node_next" }
func (*AddNodeNext) GetCrcString() string            { return "2457116d" }
func (*AddNodeNext) GetMessageType() api.MessageType { return api.RequestMessage }

func (m *AddNodeNext) Size() int {
	if m == nil {
		return 0
	}
	var size int
	// field[1] m.NodeName
	size += 64
	// field[1] m.NextName
	size += 64
	return size
}
func (m *AddNodeNext) Marshal(b []byte) ([]byte, error) {
	o := binary.BigEndian
	_ = o
	pos := 0
	_ = pos
	var buf []byte
	if b == nil {
		buf = make([]byte, m.Size())
	} else {
		buf = b
	}
	// field[1] m.NodeName
	copy(buf[pos:pos+64], m.NodeName)
	pos += 64
	// field[1] m.NextName
	copy(buf[pos:pos+64], m.NextName)
	pos += 64
	return buf, nil
}
func (m *AddNodeNext) Unmarshal(tmp []byte) error {
	o := binary.BigEndian
	_ = o
	pos := 0
	_ = pos
	// field[1] m.NodeName
	{
		nul := bytes.Index(tmp[pos:pos+64], []byte{0x00})
		m.NodeName = codec.DecodeString(tmp[pos : pos+nul])
		pos += 64
	}
	// field[1] m.NextName
	{
		nul := bytes.Index(tmp[pos:pos+64], []byte{0x00})
		m.NextName = codec.DecodeString(tmp[pos : pos+nul])
		pos += 64
	}
	return nil
}

// AddNodeNextReply represents VPP binary API message 'add_node_next_reply'.
type AddNodeNextReply struct {
	Retval    int32  `binapi:"i32,name=retval" json:"retval,omitempty"`
	NextIndex uint32 `binapi:"u32,name=next_index" json:"next_index,omitempty"`
}

func (m *AddNodeNextReply) Reset()                        { *m = AddNodeNextReply{} }
func (*AddNodeNextReply) GetMessageName() string          { return "add_node_next_reply" }
func (*AddNodeNextReply) GetCrcString() string            { return "2ed75f32" }
func (*AddNodeNextReply) GetMessageType() api.MessageType { return api.ReplyMessage }

func (m *AddNodeNextReply) Size() int {
	if m == nil {
		return 0
	}
	var size int
	// field[1] m.Retval
	size += 4
	// field[1] m.NextIndex
	size += 4
	return size
}
func (m *AddNodeNextReply) Marshal(b []byte) ([]byte, error) {
	o := binary.BigEndian
	_ = o
	pos := 0
	_ = pos
	var buf []byte
	if b == nil {
		buf = make([]byte, m.Size())
	} else {
		buf = b
	}
	// field[1] m.Retval
	o.PutUint32(buf[pos:pos+4], uint32(m.Retval))
	pos += 4
	// field[1] m.NextIndex
	o.PutUint32(buf[pos:pos+4], uint32(m.NextIndex))
	pos += 4
	return buf, nil
}
func (m *AddNodeNextReply) Unmarshal(tmp []byte) error {
	o := binary.BigEndian
	_ = o
	pos := 0
	_ = pos
	// field[1] m.Retval
	m.Retval = int32(o.Uint32(tmp[pos : pos+4]))
	pos += 4
	// field[1] m.NextIndex
	m.NextIndex = uint32(o.Uint32(tmp[pos : pos+4]))
	pos += 4
	return nil
}

// Cli represents VPP binary API message 'cli'.
type Cli struct {
	CmdInShmem uint64 `binapi:"u64,name=cmd_in_shmem" json:"cmd_in_shmem,omitempty"`
}

func (m *Cli) Reset()                        { *m = Cli{} }
func (*Cli) GetMessageName() string          { return "cli" }
func (*Cli) GetCrcString() string            { return "23bfbfff" }
func (*Cli) GetMessageType() api.MessageType { return api.RequestMessage }

func (m *Cli) Size() int {
	if m == nil {
		return 0
	}
	var size int
	// field[1] m.CmdInShmem
	size += 8
	return size
}
func (m *Cli) Marshal(b []byte) ([]byte, error) {
	o := binary.BigEndian
	_ = o
	pos := 0
	_ = pos
	var buf []byte
	if b == nil {
		buf = make([]byte, m.Size())
	} else {
		buf = b
	}
	// field[1] m.CmdInShmem
	o.PutUint64(buf[pos:pos+8], uint64(m.CmdInShmem))
	pos += 8
	return buf, nil
}
func (m *Cli) Unmarshal(tmp []byte) error {
	o := binary.BigEndian
	_ = o
	pos := 0
	_ = pos
	// field[1] m.CmdInShmem
	m.CmdInShmem = uint64(o.Uint64(tmp[pos : pos+8]))
	pos += 8
	return nil
}

// CliInband represents VPP binary API message 'cli_inband'.
type CliInband struct {
	XXX_CmdLen uint32 `struc:"sizeof=Cmd"`
	Cmd        string `json:"cmd,omitempty"`
}

func (m *CliInband) Reset()                        { *m = CliInband{} }
func (*CliInband) GetMessageName() string          { return "cli_inband" }
func (*CliInband) GetCrcString() string            { return "f8377302" }
func (*CliInband) GetMessageType() api.MessageType { return api.RequestMessage }

func (m *CliInband) Size() int {
	if m == nil {
		return 0
	}
	var size int
	// field[1] m.Cmd
	size += 4 + len(m.Cmd)
	return size
}
func (m *CliInband) Marshal(b []byte) ([]byte, error) {
	o := binary.BigEndian
	_ = o
	pos := 0
	_ = pos
	var buf []byte
	if b == nil {
		buf = make([]byte, m.Size())
	} else {
		buf = b
	}
	// field[1] m.Cmd
	o.PutUint32(buf[pos:pos+4], uint32(len(m.Cmd)))
	pos += 4
	copy(buf[pos:pos+len(m.Cmd)], m.Cmd[:])
	pos += len(m.Cmd)
	return buf, nil
}
func (m *CliInband) Unmarshal(tmp []byte) error {
	o := binary.BigEndian
	_ = o
	pos := 0
	_ = pos
	// field[1] m.Cmd
	{
		siz := o.Uint32(tmp[pos : pos+4])
		pos += 4
		m.Cmd = codec.DecodeString(tmp[pos : pos+int(siz)])
		pos += len(m.Cmd)
	}
	return nil
}

// CliInbandReply represents VPP binary API message 'cli_inband_reply'.
type CliInbandReply struct {
	Retval       int32  `binapi:"i32,name=retval" json:"retval,omitempty"`
	XXX_ReplyLen uint32 `struc:"sizeof=Reply"`
	Reply        string `json:"reply,omitempty"`
}

func (m *CliInbandReply) Reset()                        { *m = CliInbandReply{} }
func (*CliInbandReply) GetMessageName() string          { return "cli_inband_reply" }
func (*CliInbandReply) GetCrcString() string            { return "05879051" }
func (*CliInbandReply) GetMessageType() api.MessageType { return api.ReplyMessage }

func (m *CliInbandReply) Size() int {
	if m == nil {
		return 0
	}
	var size int
	// field[1] m.Retval
	size += 4
	// field[1] m.Reply
	size += 4 + len(m.Reply)
	return size
}
func (m *CliInbandReply) Marshal(b []byte) ([]byte, error) {
	o := binary.BigEndian
	_ = o
	pos := 0
	_ = pos
	var buf []byte
	if b == nil {
		buf = make([]byte, m.Size())
	} else {
		buf = b
	}
	// field[1] m.Retval
	o.PutUint32(buf[pos:pos+4], uint32(m.Retval))
	pos += 4
	// field[1] m.Reply
	o.PutUint32(buf[pos:pos+4], uint32(len(m.Reply)))
	pos += 4
	copy(buf[pos:pos+len(m.Reply)], m.Reply[:])
	pos += len(m.Reply)
	return buf, nil
}
func (m *CliInbandReply) Unmarshal(tmp []byte) error {
	o := binary.BigEndian
	_ = o
	pos := 0
	_ = pos
	// field[1] m.Retval
	m.Retval = int32(o.Uint32(tmp[pos : pos+4]))
	pos += 4
	// field[1] m.Reply
	{
		siz := o.Uint32(tmp[pos : pos+4])
		pos += 4
		m.Reply = codec.DecodeString(tmp[pos : pos+int(siz)])
		pos += len(m.Reply)
	}
	return nil
}

// CliReply represents VPP binary API message 'cli_reply'.
type CliReply struct {
	Retval       int32  `binapi:"i32,name=retval" json:"retval,omitempty"`
	ReplyInShmem uint64 `binapi:"u64,name=reply_in_shmem" json:"reply_in_shmem,omitempty"`
}

func (m *CliReply) Reset()                        { *m = CliReply{} }
func (*CliReply) GetMessageName() string          { return "cli_reply" }
func (*CliReply) GetCrcString() string            { return "06d68297" }
func (*CliReply) GetMessageType() api.MessageType { return api.ReplyMessage }

func (m *CliReply) Size() int {
	if m == nil {
		return 0
	}
	var size int
	// field[1] m.Retval
	size += 4
	// field[1] m.ReplyInShmem
	size += 8
	return size
}
func (m *CliReply) Marshal(b []byte) ([]byte, error) {
	o := binary.BigEndian
	_ = o
	pos := 0
	_ = pos
	var buf []byte
	if b == nil {
		buf = make([]byte, m.Size())
	} else {
		buf = b
	}
	// field[1] m.Retval
	o.PutUint32(buf[pos:pos+4], uint32(m.Retval))
	pos += 4
	// field[1] m.ReplyInShmem
	o.PutUint64(buf[pos:pos+8], uint64(m.ReplyInShmem))
	pos += 8
	return buf, nil
}
func (m *CliReply) Unmarshal(tmp []byte) error {
	o := binary.BigEndian
	_ = o
	pos := 0
	_ = pos
	// field[1] m.Retval
	m.Retval = int32(o.Uint32(tmp[pos : pos+4]))
	pos += 4
	// field[1] m.ReplyInShmem
	m.ReplyInShmem = uint64(o.Uint64(tmp[pos : pos+8]))
	pos += 8
	return nil
}

// ControlPing represents VPP binary API message 'control_ping'.
type ControlPing struct{}

func (m *ControlPing) Reset()                        { *m = ControlPing{} }
func (*ControlPing) GetMessageName() string          { return "control_ping" }
func (*ControlPing) GetCrcString() string            { return "51077d14" }
func (*ControlPing) GetMessageType() api.MessageType { return api.RequestMessage }

func (m *ControlPing) Size() int {
	if m == nil {
		return 0
	}
	var size int
	return size
}
func (m *ControlPing) Marshal(b []byte) ([]byte, error) {
	o := binary.BigEndian
	_ = o
	pos := 0
	_ = pos
	var buf []byte
	if b == nil {
		buf = make([]byte, m.Size())
	} else {
		buf = b
	}
	return buf, nil
}
func (m *ControlPing) Unmarshal(tmp []byte) error {
	o := binary.BigEndian
	_ = o
	pos := 0
	_ = pos
	return nil
}

// ControlPingReply represents VPP binary API message 'control_ping_reply'.
type ControlPingReply struct {
	Retval      int32  `binapi:"i32,name=retval" json:"retval,omitempty"`
	ClientIndex uint32 `binapi:"u32,name=client_index" json:"client_index,omitempty"`
	VpePID      uint32 `binapi:"u32,name=vpe_pid" json:"vpe_pid,omitempty"`
}

func (m *ControlPingReply) Reset()                        { *m = ControlPingReply{} }
func (*ControlPingReply) GetMessageName() string          { return "control_ping_reply" }
func (*ControlPingReply) GetCrcString() string            { return "f6b0b8ca" }
func (*ControlPingReply) GetMessageType() api.MessageType { return api.ReplyMessage }

func (m *ControlPingReply) Size() int {
	if m == nil {
		return 0
	}
	var size int
	// field[1] m.Retval
	size += 4
	// field[1] m.ClientIndex
	size += 4
	// field[1] m.VpePID
	size += 4
	return size
}
func (m *ControlPingReply) Marshal(b []byte) ([]byte, error) {
	o := binary.BigEndian
	_ = o
	pos := 0
	_ = pos
	var buf []byte
	if b == nil {
		buf = make([]byte, m.Size())
	} else {
		buf = b
	}
	// field[1] m.Retval
	o.PutUint32(buf[pos:pos+4], uint32(m.Retval))
	pos += 4
	// field[1] m.ClientIndex
	o.PutUint32(buf[pos:pos+4], uint32(m.ClientIndex))
	pos += 4
	// field[1] m.VpePID
	o.PutUint32(buf[pos:pos+4], uint32(m.VpePID))
	pos += 4
	return buf, nil
}
func (m *ControlPingReply) Unmarshal(tmp []byte) error {
	o := binary.BigEndian
	_ = o
	pos := 0
	_ = pos
	// field[1] m.Retval
	m.Retval = int32(o.Uint32(tmp[pos : pos+4]))
	pos += 4
	// field[1] m.ClientIndex
	m.ClientIndex = uint32(o.Uint32(tmp[pos : pos+4]))
	pos += 4
	// field[1] m.VpePID
	m.VpePID = uint32(o.Uint32(tmp[pos : pos+4]))
	pos += 4
	return nil
}

// GetF64EndianValue represents VPP binary API message 'get_f64_endian_value'.
type GetF64EndianValue struct {
	F64One float64 `binapi:"f64,name=f64_one,default=1" json:"f64_one,omitempty"`
}

func (m *GetF64EndianValue) Reset()                        { *m = GetF64EndianValue{} }
func (*GetF64EndianValue) GetMessageName() string          { return "get_f64_endian_value" }
func (*GetF64EndianValue) GetCrcString() string            { return "809fcd44" }
func (*GetF64EndianValue) GetMessageType() api.MessageType { return api.RequestMessage }

func (m *GetF64EndianValue) Size() int {
	if m == nil {
		return 0
	}
	var size int
	// field[1] m.F64One
	size += 8
	return size
}
func (m *GetF64EndianValue) Marshal(b []byte) ([]byte, error) {
	o := binary.BigEndian
	_ = o
	pos := 0
	_ = pos
	var buf []byte
	if b == nil {
		buf = make([]byte, m.Size())
	} else {
		buf = b
	}
	// field[1] m.F64One
	o.PutUint64(buf[pos:pos+8], math.Float64bits(float64(m.F64One)))
	pos += 8
	return buf, nil
}
func (m *GetF64EndianValue) Unmarshal(tmp []byte) error {
	o := binary.BigEndian
	_ = o
	pos := 0
	_ = pos
	// field[1] m.F64One
	m.F64One = float64(math.Float64frombits(o.Uint64(tmp[pos : pos+8])))
	pos += 8
	return nil
}

// GetF64EndianValueReply represents VPP binary API message 'get_f64_endian_value_reply'.
type GetF64EndianValueReply struct {
	Retval       uint32  `binapi:"u32,name=retval" json:"retval,omitempty"`
	F64OneResult float64 `binapi:"f64,name=f64_one_result" json:"f64_one_result,omitempty"`
}

func (m *GetF64EndianValueReply) Reset()                        { *m = GetF64EndianValueReply{} }
func (*GetF64EndianValueReply) GetMessageName() string          { return "get_f64_endian_value_reply" }
func (*GetF64EndianValueReply) GetCrcString() string            { return "7e02e404" }
func (*GetF64EndianValueReply) GetMessageType() api.MessageType { return api.ReplyMessage }

func (m *GetF64EndianValueReply) Size() int {
	if m == nil {
		return 0
	}
	var size int
	// field[1] m.Retval
	size += 4
	// field[1] m.F64OneResult
	size += 8
	return size
}
func (m *GetF64EndianValueReply) Marshal(b []byte) ([]byte, error) {
	o := binary.BigEndian
	_ = o
	pos := 0
	_ = pos
	var buf []byte
	if b == nil {
		buf = make([]byte, m.Size())
	} else {
		buf = b
	}
	// field[1] m.Retval
	o.PutUint32(buf[pos:pos+4], uint32(m.Retval))
	pos += 4
	// field[1] m.F64OneResult
	o.PutUint64(buf[pos:pos+8], math.Float64bits(float64(m.F64OneResult)))
	pos += 8
	return buf, nil
}
func (m *GetF64EndianValueReply) Unmarshal(tmp []byte) error {
	o := binary.BigEndian
	_ = o
	pos := 0
	_ = pos
	// field[1] m.Retval
	m.Retval = uint32(o.Uint32(tmp[pos : pos+4]))
	pos += 4
	// field[1] m.F64OneResult
	m.F64OneResult = float64(math.Float64frombits(o.Uint64(tmp[pos : pos+8])))
	pos += 8
	return nil
}

// GetF64IncrementByOne represents VPP binary API message 'get_f64_increment_by_one'.
type GetF64IncrementByOne struct {
	F64Value float64 `binapi:"f64,name=f64_value,default=1" json:"f64_value,omitempty"`
}

func (m *GetF64IncrementByOne) Reset()                        { *m = GetF64IncrementByOne{} }
func (*GetF64IncrementByOne) GetMessageName() string          { return "get_f64_increment_by_one" }
func (*GetF64IncrementByOne) GetCrcString() string            { return "b64f027e" }
func (*GetF64IncrementByOne) GetMessageType() api.MessageType { return api.RequestMessage }

func (m *GetF64IncrementByOne) Size() int {
	if m == nil {
		return 0
	}
	var size int
	// field[1] m.F64Value
	size += 8
	return size
}
func (m *GetF64IncrementByOne) Marshal(b []byte) ([]byte, error) {
	o := binary.BigEndian
	_ = o
	pos := 0
	_ = pos
	var buf []byte
	if b == nil {
		buf = make([]byte, m.Size())
	} else {
		buf = b
	}
	// field[1] m.F64Value
	o.PutUint64(buf[pos:pos+8], math.Float64bits(float64(m.F64Value)))
	pos += 8
	return buf, nil
}
func (m *GetF64IncrementByOne) Unmarshal(tmp []byte) error {
	o := binary.BigEndian
	_ = o
	pos := 0
	_ = pos
	// field[1] m.F64Value
	m.F64Value = float64(math.Float64frombits(o.Uint64(tmp[pos : pos+8])))
	pos += 8
	return nil
}

// GetF64IncrementByOneReply represents VPP binary API message 'get_f64_increment_by_one_reply'.
type GetF64IncrementByOneReply struct {
	Retval   uint32  `binapi:"u32,name=retval" json:"retval,omitempty"`
	F64Value float64 `binapi:"f64,name=f64_value" json:"f64_value,omitempty"`
}

func (m *GetF64IncrementByOneReply) Reset()                        { *m = GetF64IncrementByOneReply{} }
func (*GetF64IncrementByOneReply) GetMessageName() string          { return "get_f64_increment_by_one_reply" }
func (*GetF64IncrementByOneReply) GetCrcString() string            { return "d25dbaa3" }
func (*GetF64IncrementByOneReply) GetMessageType() api.MessageType { return api.ReplyMessage }

func (m *GetF64IncrementByOneReply) Size() int {
	if m == nil {
		return 0
	}
	var size int
	// field[1] m.Retval
	size += 4
	// field[1] m.F64Value
	size += 8
	return size
}
func (m *GetF64IncrementByOneReply) Marshal(b []byte) ([]byte, error) {
	o := binary.BigEndian
	_ = o
	pos := 0
	_ = pos
	var buf []byte
	if b == nil {
		buf = make([]byte, m.Size())
	} else {
		buf = b
	}
	// field[1] m.Retval
	o.PutUint32(buf[pos:pos+4], uint32(m.Retval))
	pos += 4
	// field[1] m.F64Value
	o.PutUint64(buf[pos:pos+8], math.Float64bits(float64(m.F64Value)))
	pos += 8
	return buf, nil
}
func (m *GetF64IncrementByOneReply) Unmarshal(tmp []byte) error {
	o := binary.BigEndian
	_ = o
	pos := 0
	_ = pos
	// field[1] m.Retval
	m.Retval = uint32(o.Uint32(tmp[pos : pos+4]))
	pos += 4
	// field[1] m.F64Value
	m.F64Value = float64(math.Float64frombits(o.Uint64(tmp[pos : pos+8])))
	pos += 8
	return nil
}

// GetNextIndex represents VPP binary API message 'get_next_index'.
type GetNextIndex struct {
	NodeName string `binapi:"string[64],name=node_name" json:"node_name,omitempty" struc:"[64]byte"`
	NextName string `binapi:"string[64],name=next_name" json:"next_name,omitempty" struc:"[64]byte"`
}

func (m *GetNextIndex) Reset()                        { *m = GetNextIndex{} }
func (*GetNextIndex) GetMessageName() string          { return "get_next_index" }
func (*GetNextIndex) GetCrcString() string            { return "2457116d" }
func (*GetNextIndex) GetMessageType() api.MessageType { return api.RequestMessage }

func (m *GetNextIndex) Size() int {
	if m == nil {
		return 0
	}
	var size int
	// field[1] m.NodeName
	size += 64
	// field[1] m.NextName
	size += 64
	return size
}
func (m *GetNextIndex) Marshal(b []byte) ([]byte, error) {
	o := binary.BigEndian
	_ = o
	pos := 0
	_ = pos
	var buf []byte
	if b == nil {
		buf = make([]byte, m.Size())
	} else {
		buf = b
	}
	// field[1] m.NodeName
	copy(buf[pos:pos+64], m.NodeName)
	pos += 64
	// field[1] m.NextName
	copy(buf[pos:pos+64], m.NextName)
	pos += 64
	return buf, nil
}
func (m *GetNextIndex) Unmarshal(tmp []byte) error {
	o := binary.BigEndian
	_ = o
	pos := 0
	_ = pos
	// field[1] m.NodeName
	{
		nul := bytes.Index(tmp[pos:pos+64], []byte{0x00})
		m.NodeName = codec.DecodeString(tmp[pos : pos+nul])
		pos += 64
	}
	// field[1] m.NextName
	{
		nul := bytes.Index(tmp[pos:pos+64], []byte{0x00})
		m.NextName = codec.DecodeString(tmp[pos : pos+nul])
		pos += 64
	}
	return nil
}

// GetNextIndexReply represents VPP binary API message 'get_next_index_reply'.
type GetNextIndexReply struct {
	Retval    int32  `binapi:"i32,name=retval" json:"retval,omitempty"`
	NextIndex uint32 `binapi:"u32,name=next_index" json:"next_index,omitempty"`
}

func (m *GetNextIndexReply) Reset()                        { *m = GetNextIndexReply{} }
func (*GetNextIndexReply) GetMessageName() string          { return "get_next_index_reply" }
func (*GetNextIndexReply) GetCrcString() string            { return "2ed75f32" }
func (*GetNextIndexReply) GetMessageType() api.MessageType { return api.ReplyMessage }

func (m *GetNextIndexReply) Size() int {
	if m == nil {
		return 0
	}
	var size int
	// field[1] m.Retval
	size += 4
	// field[1] m.NextIndex
	size += 4
	return size
}
func (m *GetNextIndexReply) Marshal(b []byte) ([]byte, error) {
	o := binary.BigEndian
	_ = o
	pos := 0
	_ = pos
	var buf []byte
	if b == nil {
		buf = make([]byte, m.Size())
	} else {
		buf = b
	}
	// field[1] m.Retval
	o.PutUint32(buf[pos:pos+4], uint32(m.Retval))
	pos += 4
	// field[1] m.NextIndex
	o.PutUint32(buf[pos:pos+4], uint32(m.NextIndex))
	pos += 4
	return buf, nil
}
func (m *GetNextIndexReply) Unmarshal(tmp []byte) error {
	o := binary.BigEndian
	_ = o
	pos := 0
	_ = pos
	// field[1] m.Retval
	m.Retval = int32(o.Uint32(tmp[pos : pos+4]))
	pos += 4
	// field[1] m.NextIndex
	m.NextIndex = uint32(o.Uint32(tmp[pos : pos+4]))
	pos += 4
	return nil
}

// GetNodeGraph represents VPP binary API message 'get_node_graph'.
type GetNodeGraph struct{}

func (m *GetNodeGraph) Reset()                        { *m = GetNodeGraph{} }
func (*GetNodeGraph) GetMessageName() string          { return "get_node_graph" }
func (*GetNodeGraph) GetCrcString() string            { return "51077d14" }
func (*GetNodeGraph) GetMessageType() api.MessageType { return api.RequestMessage }

func (m *GetNodeGraph) Size() int {
	if m == nil {
		return 0
	}
	var size int
	return size
}
func (m *GetNodeGraph) Marshal(b []byte) ([]byte, error) {
	o := binary.BigEndian
	_ = o
	pos := 0
	_ = pos
	var buf []byte
	if b == nil {
		buf = make([]byte, m.Size())
	} else {
		buf = b
	}
	return buf, nil
}
func (m *GetNodeGraph) Unmarshal(tmp []byte) error {
	o := binary.BigEndian
	_ = o
	pos := 0
	_ = pos
	return nil
}

// GetNodeGraphReply represents VPP binary API message 'get_node_graph_reply'.
type GetNodeGraphReply struct {
	Retval       int32  `binapi:"i32,name=retval" json:"retval,omitempty"`
	ReplyInShmem uint64 `binapi:"u64,name=reply_in_shmem" json:"reply_in_shmem,omitempty"`
}

func (m *GetNodeGraphReply) Reset()                        { *m = GetNodeGraphReply{} }
func (*GetNodeGraphReply) GetMessageName() string          { return "get_node_graph_reply" }
func (*GetNodeGraphReply) GetCrcString() string            { return "06d68297" }
func (*GetNodeGraphReply) GetMessageType() api.MessageType { return api.ReplyMessage }

func (m *GetNodeGraphReply) Size() int {
	if m == nil {
		return 0
	}
	var size int
	// field[1] m.Retval
	size += 4
	// field[1] m.ReplyInShmem
	size += 8
	return size
}
func (m *GetNodeGraphReply) Marshal(b []byte) ([]byte, error) {
	o := binary.BigEndian
	_ = o
	pos := 0
	_ = pos
	var buf []byte
	if b == nil {
		buf = make([]byte, m.Size())
	} else {
		buf = b
	}
	// field[1] m.Retval
	o.PutUint32(buf[pos:pos+4], uint32(m.Retval))
	pos += 4
	// field[1] m.ReplyInShmem
	o.PutUint64(buf[pos:pos+8], uint64(m.ReplyInShmem))
	pos += 8
	return buf, nil
}
func (m *GetNodeGraphReply) Unmarshal(tmp []byte) error {
	o := binary.BigEndian
	_ = o
	pos := 0
	_ = pos
	// field[1] m.Retval
	m.Retval = int32(o.Uint32(tmp[pos : pos+4]))
	pos += 4
	// field[1] m.ReplyInShmem
	m.ReplyInShmem = uint64(o.Uint64(tmp[pos : pos+8]))
	pos += 8
	return nil
}

// GetNodeIndex represents VPP binary API message 'get_node_index'.
type GetNodeIndex struct {
	NodeName string `binapi:"string[64],name=node_name" json:"node_name,omitempty" struc:"[64]byte"`
}

func (m *GetNodeIndex) Reset()                        { *m = GetNodeIndex{} }
func (*GetNodeIndex) GetMessageName() string          { return "get_node_index" }
func (*GetNodeIndex) GetCrcString() string            { return "f1984c64" }
func (*GetNodeIndex) GetMessageType() api.MessageType { return api.RequestMessage }

func (m *GetNodeIndex) Size() int {
	if m == nil {
		return 0
	}
	var size int
	// field[1] m.NodeName
	size += 64
	return size
}
func (m *GetNodeIndex) Marshal(b []byte) ([]byte, error) {
	o := binary.BigEndian
	_ = o
	pos := 0
	_ = pos
	var buf []byte
	if b == nil {
		buf = make([]byte, m.Size())
	} else {
		buf = b
	}
	// field[1] m.NodeName
	copy(buf[pos:pos+64], m.NodeName)
	pos += 64
	return buf, nil
}
func (m *GetNodeIndex) Unmarshal(tmp []byte) error {
	o := binary.BigEndian
	_ = o
	pos := 0
	_ = pos
	// field[1] m.NodeName
	{
		nul := bytes.Index(tmp[pos:pos+64], []byte{0x00})
		m.NodeName = codec.DecodeString(tmp[pos : pos+nul])
		pos += 64
	}
	return nil
}

// GetNodeIndexReply represents VPP binary API message 'get_node_index_reply'.
type GetNodeIndexReply struct {
	Retval    int32  `binapi:"i32,name=retval" json:"retval,omitempty"`
	NodeIndex uint32 `binapi:"u32,name=node_index" json:"node_index,omitempty"`
}

func (m *GetNodeIndexReply) Reset()                        { *m = GetNodeIndexReply{} }
func (*GetNodeIndexReply) GetMessageName() string          { return "get_node_index_reply" }
func (*GetNodeIndexReply) GetCrcString() string            { return "a8600b89" }
func (*GetNodeIndexReply) GetMessageType() api.MessageType { return api.ReplyMessage }

func (m *GetNodeIndexReply) Size() int {
	if m == nil {
		return 0
	}
	var size int
	// field[1] m.Retval
	size += 4
	// field[1] m.NodeIndex
	size += 4
	return size
}
func (m *GetNodeIndexReply) Marshal(b []byte) ([]byte, error) {
	o := binary.BigEndian
	_ = o
	pos := 0
	_ = pos
	var buf []byte
	if b == nil {
		buf = make([]byte, m.Size())
	} else {
		buf = b
	}
	// field[1] m.Retval
	o.PutUint32(buf[pos:pos+4], uint32(m.Retval))
	pos += 4
	// field[1] m.NodeIndex
	o.PutUint32(buf[pos:pos+4], uint32(m.NodeIndex))
	pos += 4
	return buf, nil
}
func (m *GetNodeIndexReply) Unmarshal(tmp []byte) error {
	o := binary.BigEndian
	_ = o
	pos := 0
	_ = pos
	// field[1] m.Retval
	m.Retval = int32(o.Uint32(tmp[pos : pos+4]))
	pos += 4
	// field[1] m.NodeIndex
	m.NodeIndex = uint32(o.Uint32(tmp[pos : pos+4]))
	pos += 4
	return nil
}

// LogDetails represents VPP binary API message 'log_details'.
type LogDetails struct {
	Timestamp Timestamp `binapi:"timestamp,name=timestamp" json:"timestamp,omitempty"`
	Level     LogLevel  `binapi:"log_level,name=level" json:"level,omitempty"`
	MsgClass  string    `binapi:"string[32],name=msg_class" json:"msg_class,omitempty" struc:"[32]byte"`
	Message   string    `binapi:"string[256],name=message" json:"message,omitempty" struc:"[256]byte"`
}

func (m *LogDetails) Reset()                        { *m = LogDetails{} }
func (*LogDetails) GetMessageName() string          { return "log_details" }
func (*LogDetails) GetCrcString() string            { return "255827a1" }
func (*LogDetails) GetMessageType() api.MessageType { return api.ReplyMessage }

func (m *LogDetails) Size() int {
	if m == nil {
		return 0
	}
	var size int
	// field[1] m.Timestamp
	size += 8
	// field[1] m.Level
	size += 4
	// field[1] m.MsgClass
	size += 32
	// field[1] m.Message
	size += 256
	return size
}
func (m *LogDetails) Marshal(b []byte) ([]byte, error) {
	o := binary.BigEndian
	_ = o
	pos := 0
	_ = pos
	var buf []byte
	if b == nil {
		buf = make([]byte, m.Size())
	} else {
		buf = b
	}
	// field[1] m.Timestamp
	o.PutUint64(buf[pos:pos+8], math.Float64bits(float64(m.Timestamp)))
	pos += 8
	// field[1] m.Level
	o.PutUint32(buf[pos:pos+4], uint32(m.Level))
	pos += 4
	// field[1] m.MsgClass
	copy(buf[pos:pos+32], m.MsgClass)
	pos += 32
	// field[1] m.Message
	copy(buf[pos:pos+256], m.Message)
	pos += 256
	return buf, nil
}
func (m *LogDetails) Unmarshal(tmp []byte) error {
	o := binary.BigEndian
	_ = o
	pos := 0
	_ = pos
	// field[1] m.Timestamp
	m.Timestamp = Timestamp(math.Float64frombits(o.Uint64(tmp[pos : pos+8])))
	pos += 8
	// field[1] m.Level
	m.Level = LogLevel(o.Uint32(tmp[pos : pos+4]))
	pos += 4
	// field[1] m.MsgClass
	{
		nul := bytes.Index(tmp[pos:pos+32], []byte{0x00})
		m.MsgClass = codec.DecodeString(tmp[pos : pos+nul])
		pos += 32
	}
	// field[1] m.Message
	{
		nul := bytes.Index(tmp[pos:pos+256], []byte{0x00})
		m.Message = codec.DecodeString(tmp[pos : pos+nul])
		pos += 256
	}
	return nil
}

// LogDump represents VPP binary API message 'log_dump'.
type LogDump struct {
	StartTimestamp Timestamp `binapi:"timestamp,name=start_timestamp" json:"start_timestamp,omitempty"`
}

func (m *LogDump) Reset()                        { *m = LogDump{} }
func (*LogDump) GetMessageName() string          { return "log_dump" }
func (*LogDump) GetCrcString() string            { return "6ab31753" }
func (*LogDump) GetMessageType() api.MessageType { return api.RequestMessage }

func (m *LogDump) Size() int {
	if m == nil {
		return 0
	}
	var size int
	// field[1] m.StartTimestamp
	size += 8
	return size
}
func (m *LogDump) Marshal(b []byte) ([]byte, error) {
	o := binary.BigEndian
	_ = o
	pos := 0
	_ = pos
	var buf []byte
	if b == nil {
		buf = make([]byte, m.Size())
	} else {
		buf = b
	}
	// field[1] m.StartTimestamp
	o.PutUint64(buf[pos:pos+8], math.Float64bits(float64(m.StartTimestamp)))
	pos += 8
	return buf, nil
}
func (m *LogDump) Unmarshal(tmp []byte) error {
	o := binary.BigEndian
	_ = o
	pos := 0
	_ = pos
	// field[1] m.StartTimestamp
	m.StartTimestamp = Timestamp(math.Float64frombits(o.Uint64(tmp[pos : pos+8])))
	pos += 8
	return nil
}

// ShowThreads represents VPP binary API message 'show_threads'.
type ShowThreads struct{}

func (m *ShowThreads) Reset()                        { *m = ShowThreads{} }
func (*ShowThreads) GetMessageName() string          { return "show_threads" }
func (*ShowThreads) GetCrcString() string            { return "51077d14" }
func (*ShowThreads) GetMessageType() api.MessageType { return api.RequestMessage }

func (m *ShowThreads) Size() int {
	if m == nil {
		return 0
	}
	var size int
	return size
}
func (m *ShowThreads) Marshal(b []byte) ([]byte, error) {
	o := binary.BigEndian
	_ = o
	pos := 0
	_ = pos
	var buf []byte
	if b == nil {
		buf = make([]byte, m.Size())
	} else {
		buf = b
	}
	return buf, nil
}
func (m *ShowThreads) Unmarshal(tmp []byte) error {
	o := binary.BigEndian
	_ = o
	pos := 0
	_ = pos
	return nil
}

// ShowThreadsReply represents VPP binary API message 'show_threads_reply'.
type ShowThreadsReply struct {
	Retval     int32        `binapi:"i32,name=retval" json:"retval,omitempty"`
	Count      uint32       `binapi:"u32,name=count" json:"count,omitempty" struc:"sizeof=ThreadData"`
	ThreadData []ThreadData `binapi:"thread_data[count],name=thread_data" json:"thread_data,omitempty"`
}

func (m *ShowThreadsReply) Reset()                        { *m = ShowThreadsReply{} }
func (*ShowThreadsReply) GetMessageName() string          { return "show_threads_reply" }
func (*ShowThreadsReply) GetCrcString() string            { return "efd78e83" }
func (*ShowThreadsReply) GetMessageType() api.MessageType { return api.ReplyMessage }

func (m *ShowThreadsReply) Size() int {
	if m == nil {
		return 0
	}
	var size int
	// field[1] m.Retval
	size += 4
	// field[1] m.Count
	size += 4
	// field[1] m.ThreadData
	for j1 := 0; j1 < len(m.ThreadData); j1++ {
		var s1 ThreadData
		_ = s1
		if j1 < len(m.ThreadData) {
			s1 = m.ThreadData[j1]
		}
		// field[2] s1.ID
		size += 4
		// field[2] s1.Name
		size += 64
		// field[2] s1.Type
		size += 64
		// field[2] s1.PID
		size += 4
		// field[2] s1.CPUID
		size += 4
		// field[2] s1.Core
		size += 4
		// field[2] s1.CPUSocket
		size += 4
	}
	return size
}
func (m *ShowThreadsReply) Marshal(b []byte) ([]byte, error) {
	o := binary.BigEndian
	_ = o
	pos := 0
	_ = pos
	var buf []byte
	if b == nil {
		buf = make([]byte, m.Size())
	} else {
		buf = b
	}
	// field[1] m.Retval
	o.PutUint32(buf[pos:pos+4], uint32(m.Retval))
	pos += 4
	// field[1] m.Count
	o.PutUint32(buf[pos:pos+4], uint32(len(m.ThreadData)))
	pos += 4
	// field[1] m.ThreadData
	for j1 := 0; j1 < len(m.ThreadData); j1++ {
		var v1 ThreadData
		if j1 < len(m.ThreadData) {
			v1 = m.ThreadData[j1]
		}
		// field[2] v1.ID
		o.PutUint32(buf[pos:pos+4], uint32(v1.ID))
		pos += 4
		// field[2] v1.Name
		copy(buf[pos:pos+64], v1.Name)
		pos += 64
		// field[2] v1.Type
		copy(buf[pos:pos+64], v1.Type)
		pos += 64
		// field[2] v1.PID
		o.PutUint32(buf[pos:pos+4], uint32(v1.PID))
		pos += 4
		// field[2] v1.CPUID
		o.PutUint32(buf[pos:pos+4], uint32(v1.CPUID))
		pos += 4
		// field[2] v1.Core
		o.PutUint32(buf[pos:pos+4], uint32(v1.Core))
		pos += 4
		// field[2] v1.CPUSocket
		o.PutUint32(buf[pos:pos+4], uint32(v1.CPUSocket))
		pos += 4
	}
	return buf, nil
}
func (m *ShowThreadsReply) Unmarshal(tmp []byte) error {
	o := binary.BigEndian
	_ = o
	pos := 0
	_ = pos
	// field[1] m.Retval
	m.Retval = int32(o.Uint32(tmp[pos : pos+4]))
	pos += 4
	// field[1] m.Count
	m.Count = uint32(o.Uint32(tmp[pos : pos+4]))
	pos += 4
	// field[1] m.ThreadData
	m.ThreadData = make([]ThreadData, int(m.Count))
	for j1 := 0; j1 < int(m.Count); j1++ {
		// field[2] m.ThreadData[j1].ID
		m.ThreadData[j1].ID = uint32(o.Uint32(tmp[pos : pos+4]))
		pos += 4
		// field[2] m.ThreadData[j1].Name
		{
			nul := bytes.Index(tmp[pos:pos+64], []byte{0x00})
			m.ThreadData[j1].Name = codec.DecodeString(tmp[pos : pos+nul])
			pos += 64
		}
		// field[2] m.ThreadData[j1].Type
		{
			nul := bytes.Index(tmp[pos:pos+64], []byte{0x00})
			m.ThreadData[j1].Type = codec.DecodeString(tmp[pos : pos+nul])
			pos += 64
		}
		// field[2] m.ThreadData[j1].PID
		m.ThreadData[j1].PID = uint32(o.Uint32(tmp[pos : pos+4]))
		pos += 4
		// field[2] m.ThreadData[j1].CPUID
		m.ThreadData[j1].CPUID = uint32(o.Uint32(tmp[pos : pos+4]))
		pos += 4
		// field[2] m.ThreadData[j1].Core
		m.ThreadData[j1].Core = uint32(o.Uint32(tmp[pos : pos+4]))
		pos += 4
		// field[2] m.ThreadData[j1].CPUSocket
		m.ThreadData[j1].CPUSocket = uint32(o.Uint32(tmp[pos : pos+4]))
		pos += 4
	}
	return nil
}

// ShowVersion represents VPP binary API message 'show_version'.
type ShowVersion struct{}

func (m *ShowVersion) Reset()                        { *m = ShowVersion{} }
func (*ShowVersion) GetMessageName() string          { return "show_version" }
func (*ShowVersion) GetCrcString() string            { return "51077d14" }
func (*ShowVersion) GetMessageType() api.MessageType { return api.RequestMessage }

func (m *ShowVersion) Size() int {
	if m == nil {
		return 0
	}
	var size int
	return size
}
func (m *ShowVersion) Marshal(b []byte) ([]byte, error) {
	o := binary.BigEndian
	_ = o
	pos := 0
	_ = pos
	var buf []byte
	if b == nil {
		buf = make([]byte, m.Size())
	} else {
		buf = b
	}
	return buf, nil
}
func (m *ShowVersion) Unmarshal(tmp []byte) error {
	o := binary.BigEndian
	_ = o
	pos := 0
	_ = pos
	return nil
}

// ShowVersionReply represents VPP binary API message 'show_version_reply'.
type ShowVersionReply struct {
	Retval         int32  `binapi:"i32,name=retval" json:"retval,omitempty"`
	Program        string `binapi:"string[32],name=program" json:"program,omitempty" struc:"[32]byte"`
	Version        string `binapi:"string[32],name=version" json:"version,omitempty" struc:"[32]byte"`
	BuildDate      string `binapi:"string[32],name=build_date" json:"build_date,omitempty" struc:"[32]byte"`
	BuildDirectory string `binapi:"string[256],name=build_directory" json:"build_directory,omitempty" struc:"[256]byte"`
}

func (m *ShowVersionReply) Reset()                        { *m = ShowVersionReply{} }
func (*ShowVersionReply) GetMessageName() string          { return "show_version_reply" }
func (*ShowVersionReply) GetCrcString() string            { return "c919bde1" }
func (*ShowVersionReply) GetMessageType() api.MessageType { return api.ReplyMessage }

func (m *ShowVersionReply) Size() int {
	if m == nil {
		return 0
	}
	var size int
	// field[1] m.Retval
	size += 4
	// field[1] m.Program
	size += 32
	// field[1] m.Version
	size += 32
	// field[1] m.BuildDate
	size += 32
	// field[1] m.BuildDirectory
	size += 256
	return size
}
func (m *ShowVersionReply) Marshal(b []byte) ([]byte, error) {
	o := binary.BigEndian
	_ = o
	pos := 0
	_ = pos
	var buf []byte
	if b == nil {
		buf = make([]byte, m.Size())
	} else {
		buf = b
	}
	// field[1] m.Retval
	o.PutUint32(buf[pos:pos+4], uint32(m.Retval))
	pos += 4
	// field[1] m.Program
	copy(buf[pos:pos+32], m.Program)
	pos += 32
	// field[1] m.Version
	copy(buf[pos:pos+32], m.Version)
	pos += 32
	// field[1] m.BuildDate
	copy(buf[pos:pos+32], m.BuildDate)
	pos += 32
	// field[1] m.BuildDirectory
	copy(buf[pos:pos+256], m.BuildDirectory)
	pos += 256
	return buf, nil
}
func (m *ShowVersionReply) Unmarshal(tmp []byte) error {
	o := binary.BigEndian
	_ = o
	pos := 0
	_ = pos
	// field[1] m.Retval
	m.Retval = int32(o.Uint32(tmp[pos : pos+4]))
	pos += 4
	// field[1] m.Program
	{
		nul := bytes.Index(tmp[pos:pos+32], []byte{0x00})
		m.Program = codec.DecodeString(tmp[pos : pos+nul])
		pos += 32
	}
	// field[1] m.Version
	{
		nul := bytes.Index(tmp[pos:pos+32], []byte{0x00})
		m.Version = codec.DecodeString(tmp[pos : pos+nul])
		pos += 32
	}
	// field[1] m.BuildDate
	{
		nul := bytes.Index(tmp[pos:pos+32], []byte{0x00})
		m.BuildDate = codec.DecodeString(tmp[pos : pos+nul])
		pos += 32
	}
	// field[1] m.BuildDirectory
	{
		nul := bytes.Index(tmp[pos:pos+256], []byte{0x00})
		m.BuildDirectory = codec.DecodeString(tmp[pos : pos+nul])
		pos += 256
	}
	return nil
}

// ShowVpeSystemTime represents VPP binary API message 'show_vpe_system_time'.
type ShowVpeSystemTime struct{}

func (m *ShowVpeSystemTime) Reset()                        { *m = ShowVpeSystemTime{} }
func (*ShowVpeSystemTime) GetMessageName() string          { return "show_vpe_system_time" }
func (*ShowVpeSystemTime) GetCrcString() string            { return "51077d14" }
func (*ShowVpeSystemTime) GetMessageType() api.MessageType { return api.RequestMessage }

func (m *ShowVpeSystemTime) Size() int {
	if m == nil {
		return 0
	}
	var size int
	return size
}
func (m *ShowVpeSystemTime) Marshal(b []byte) ([]byte, error) {
	o := binary.BigEndian
	_ = o
	pos := 0
	_ = pos
	var buf []byte
	if b == nil {
		buf = make([]byte, m.Size())
	} else {
		buf = b
	}
	return buf, nil
}
func (m *ShowVpeSystemTime) Unmarshal(tmp []byte) error {
	o := binary.BigEndian
	_ = o
	pos := 0
	_ = pos
	return nil
}

// ShowVpeSystemTimeReply represents VPP binary API message 'show_vpe_system_time_reply'.
type ShowVpeSystemTimeReply struct {
	Retval        int32     `binapi:"i32,name=retval" json:"retval,omitempty"`
	VpeSystemTime Timestamp `binapi:"timestamp,name=vpe_system_time" json:"vpe_system_time,omitempty"`
}

func (m *ShowVpeSystemTimeReply) Reset()                        { *m = ShowVpeSystemTimeReply{} }
func (*ShowVpeSystemTimeReply) GetMessageName() string          { return "show_vpe_system_time_reply" }
func (*ShowVpeSystemTimeReply) GetCrcString() string            { return "7ffd8193" }
func (*ShowVpeSystemTimeReply) GetMessageType() api.MessageType { return api.ReplyMessage }

func (m *ShowVpeSystemTimeReply) Size() int {
	if m == nil {
		return 0
	}
	var size int
	// field[1] m.Retval
	size += 4
	// field[1] m.VpeSystemTime
	size += 8
	return size
}
func (m *ShowVpeSystemTimeReply) Marshal(b []byte) ([]byte, error) {
	o := binary.BigEndian
	_ = o
	pos := 0
	_ = pos
	var buf []byte
	if b == nil {
		buf = make([]byte, m.Size())
	} else {
		buf = b
	}
	// field[1] m.Retval
	o.PutUint32(buf[pos:pos+4], uint32(m.Retval))
	pos += 4
	// field[1] m.VpeSystemTime
	o.PutUint64(buf[pos:pos+8], math.Float64bits(float64(m.VpeSystemTime)))
	pos += 8
	return buf, nil
}
func (m *ShowVpeSystemTimeReply) Unmarshal(tmp []byte) error {
	o := binary.BigEndian
	_ = o
	pos := 0
	_ = pos
	// field[1] m.Retval
	m.Retval = int32(o.Uint32(tmp[pos : pos+4]))
	pos += 4
	// field[1] m.VpeSystemTime
	m.VpeSystemTime = Timestamp(math.Float64frombits(o.Uint64(tmp[pos : pos+8])))
	pos += 8
	return nil
}

func init() { file_vpe_binapi_init() }
func file_vpe_binapi_init() {
	api.RegisterMessage((*AddNodeNext)(nil), "vpe.AddNodeNext")
	api.RegisterMessage((*AddNodeNextReply)(nil), "vpe.AddNodeNextReply")
	api.RegisterMessage((*Cli)(nil), "vpe.Cli")
	api.RegisterMessage((*CliInband)(nil), "vpe.CliInband")
	api.RegisterMessage((*CliInbandReply)(nil), "vpe.CliInbandReply")
	api.RegisterMessage((*CliReply)(nil), "vpe.CliReply")
	api.RegisterMessage((*ControlPing)(nil), "vpe.ControlPing")
	api.RegisterMessage((*ControlPingReply)(nil), "vpe.ControlPingReply")
	api.RegisterMessage((*GetF64EndianValue)(nil), "vpe.GetF64EndianValue")
	api.RegisterMessage((*GetF64EndianValueReply)(nil), "vpe.GetF64EndianValueReply")
	api.RegisterMessage((*GetF64IncrementByOne)(nil), "vpe.GetF64IncrementByOne")
	api.RegisterMessage((*GetF64IncrementByOneReply)(nil), "vpe.GetF64IncrementByOneReply")
	api.RegisterMessage((*GetNextIndex)(nil), "vpe.GetNextIndex")
	api.RegisterMessage((*GetNextIndexReply)(nil), "vpe.GetNextIndexReply")
	api.RegisterMessage((*GetNodeGraph)(nil), "vpe.GetNodeGraph")
	api.RegisterMessage((*GetNodeGraphReply)(nil), "vpe.GetNodeGraphReply")
	api.RegisterMessage((*GetNodeIndex)(nil), "vpe.GetNodeIndex")
	api.RegisterMessage((*GetNodeIndexReply)(nil), "vpe.GetNodeIndexReply")
	api.RegisterMessage((*LogDetails)(nil), "vpe.LogDetails")
	api.RegisterMessage((*LogDump)(nil), "vpe.LogDump")
	api.RegisterMessage((*ShowThreads)(nil), "vpe.ShowThreads")
	api.RegisterMessage((*ShowThreadsReply)(nil), "vpe.ShowThreadsReply")
	api.RegisterMessage((*ShowVersion)(nil), "vpe.ShowVersion")
	api.RegisterMessage((*ShowVersionReply)(nil), "vpe.ShowVersionReply")
	api.RegisterMessage((*ShowVpeSystemTime)(nil), "vpe.ShowVpeSystemTime")
	api.RegisterMessage((*ShowVpeSystemTimeReply)(nil), "vpe.ShowVpeSystemTimeReply")
}

// Messages returns list of all messages in this module.
func AllMessages() []api.Message {
	return []api.Message{
		(*AddNodeNext)(nil),
		(*AddNodeNextReply)(nil),
		(*Cli)(nil),
		(*CliInband)(nil),
		(*CliInbandReply)(nil),
		(*CliReply)(nil),
		(*ControlPing)(nil),
		(*ControlPingReply)(nil),
		(*GetF64EndianValue)(nil),
		(*GetF64EndianValueReply)(nil),
		(*GetF64IncrementByOne)(nil),
		(*GetF64IncrementByOneReply)(nil),
		(*GetNextIndex)(nil),
		(*GetNextIndexReply)(nil),
		(*GetNodeGraph)(nil),
		(*GetNodeGraphReply)(nil),
		(*GetNodeIndex)(nil),
		(*GetNodeIndexReply)(nil),
		(*LogDetails)(nil),
		(*LogDump)(nil),
		(*ShowThreads)(nil),
		(*ShowThreadsReply)(nil),
		(*ShowVersion)(nil),
		(*ShowVersionReply)(nil),
		(*ShowVpeSystemTime)(nil),
		(*ShowVpeSystemTimeReply)(nil),
	}
}

// Reference imports to suppress errors if they are not otherwise used.
var _ = api.RegisterMessage
var _ = codec.DecodeString
var _ = bytes.NewBuffer
var _ = context.Background
var _ = io.Copy
var _ = strconv.Itoa
var _ = strings.Contains
var _ = struc.Pack
var _ = binary.BigEndian
var _ = math.Float32bits
var _ = net.ParseIP
var _ = fmt.Errorf