github.com/onosproject/onos-api/go@v0.10.32/onos/fabricsim/devices.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: onos/fabricsim/devices.proto

package fabricsim

import (
	context "context"
	fmt "fmt"
	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
	misc "github.com/onosproject/onos-api/go/onos/misc"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	io "io"
	math "math"
	math_bits "math/bits"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

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

// DeviceType represents type of a device, i.e. switch, IPU, etc.
type DeviceType int32

const (
	DeviceType_SWITCH DeviceType = 0
	DeviceType_IPU    DeviceType = 1
)

var DeviceType_name = map[int32]string{
	0: "SWITCH",
	1: "IPU",
}

var DeviceType_value = map[string]int32{
	"SWITCH": 0,
	"IPU":    1,
}

func (x DeviceType) String() string {
	return proto.EnumName(DeviceType_name, int32(x))
}

func (DeviceType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_7db16019df22577e, []int{0}
}

// StopMode indicates whether to simulate orderly (administrative) or chaotic (power off) shutdown
type StopMode int32

const (
	StopMode_ORDERLY_STOP StopMode = 0
	StopMode_CHAOTIC_STOP StopMode = 1
)

var StopMode_name = map[int32]string{
	0: "ORDERLY_STOP",
	1: "CHAOTIC_STOP",
}

var StopMode_value = map[string]int32{
	"ORDERLY_STOP": 0,
	"CHAOTIC_STOP": 1,
}

func (x StopMode) String() string {
	return proto.EnumName(StopMode_name, int32(x))
}

func (StopMode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_7db16019df22577e, []int{1}
}

// Device describes a simulated switch or IPU
type Device struct {
	// unique device id and device type
	ID   DeviceID   `protobuf:"bytes,1,opt,name=id,proto3,casttype=DeviceID" json:"id,omitempty"`
	Type DeviceType `protobuf:"varint,2,opt,name=type,proto3,enum=onos.fabricsim.DeviceType" json:"type,omitempty"`
	// list of ports
	Ports []*Port `protobuf:"bytes,3,rep,name=ports,proto3" json:"ports,omitempty"`
	// control port for p4 and gnmi simulation
	ControlPort int32 `protobuf:"varint,4,opt,name=control_port,json=controlPort,proto3" json:"control_port,omitempty"`
	// unique chassis ID
	ChassisID uint64 `protobuf:"varint,5,opt,name=chassis_id,json=chassisId,proto3" json:"chassis_id,omitempty"`
	// forwarding pipeline information
	PipelineInfo *PipelineInfo `protobuf:"bytes,6,opt,name=pipeline_info,json=pipelineInfo,proto3" json:"pipeline_info,omitempty"`
	// Screen coordinates
	Pos *misc.GridPosition `protobuf:"bytes,7,opt,name=pos,proto3" json:"pos,omitempty"`
	// Current connections and total connection count
	Connections      []*misc.Connection `protobuf:"bytes,8,rep,name=connections,proto3" json:"connections,omitempty"`
	TotalConnections int32              `protobuf:"varint,9,opt,name=total_connections,json=totalConnections,proto3" json:"total_connections,omitempty"`
	// Cumulative I/O stats for the device P4Runtime, gNMI and gNOI agent(s)
	IOStats *misc.IOStats `protobuf:"bytes,10,opt,name=io_stats,json=ioStats,proto3" json:"io_stats,omitempty"`
}

func (m *Device) Reset()         { *m = Device{} }
func (m *Device) String() string { return proto.CompactTextString(m) }
func (*Device) ProtoMessage()    {}
func (*Device) Descriptor() ([]byte, []int) {
	return fileDescriptor_7db16019df22577e, []int{0}
}
func (m *Device) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Device) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Device.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Device) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Device.Merge(m, src)
}
func (m *Device) XXX_Size() int {
	return m.Size()
}
func (m *Device) XXX_DiscardUnknown() {
	xxx_messageInfo_Device.DiscardUnknown(m)
}

var xxx_messageInfo_Device proto.InternalMessageInfo

func (m *Device) GetID() DeviceID {
	if m != nil {
		return m.ID
	}
	return ""
}

func (m *Device) GetType() DeviceType {
	if m != nil {
		return m.Type
	}
	return DeviceType_SWITCH
}

func (m *Device) GetPorts() []*Port {
	if m != nil {
		return m.Ports
	}
	return nil
}

func (m *Device) GetControlPort() int32 {
	if m != nil {
		return m.ControlPort
	}
	return 0
}

func (m *Device) GetChassisID() uint64 {
	if m != nil {
		return m.ChassisID
	}
	return 0
}

func (m *Device) GetPipelineInfo() *PipelineInfo {
	if m != nil {
		return m.PipelineInfo
	}
	return nil
}

func (m *Device) GetPos() *misc.GridPosition {
	if m != nil {
		return m.Pos
	}
	return nil
}

func (m *Device) GetConnections() []*misc.Connection {
	if m != nil {
		return m.Connections
	}
	return nil
}

func (m *Device) GetTotalConnections() int32 {
	if m != nil {
		return m.TotalConnections
	}
	return 0
}

func (m *Device) GetIOStats() *misc.IOStats {
	if m != nil {
		return m.IOStats
	}
	return nil
}

// Port describes a simulated device port
type Port struct {
	// unique port id and port type
	ID PortID `protobuf:"bytes,1,opt,name=id,proto3,casttype=PortID" json:"id,omitempty"`
	// display/friendly name
	Name string `protobuf:"bytes,3,opt,name=name,proto3" json:"name,omitempty"`
	// port number
	Number uint32 `protobuf:"varint,4,opt,name=number,proto3" json:"number,omitempty"`
	// sdn/internal port number
	InternalNumber uint32 `protobuf:"varint,5,opt,name=internal_number,json=internalNumber,proto3" json:"internal_number,omitempty"`
	// speed and status
	Speed   string `protobuf:"bytes,6,opt,name=speed,proto3" json:"speed,omitempty"`
	Enabled bool   `protobuf:"varint,7,opt,name=enabled,proto3" json:"enabled,omitempty"`
}

func (m *Port) Reset()         { *m = Port{} }
func (m *Port) String() string { return proto.CompactTextString(m) }
func (*Port) ProtoMessage()    {}
func (*Port) Descriptor() ([]byte, []int) {
	return fileDescriptor_7db16019df22577e, []int{1}
}
func (m *Port) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Port) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Port.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Port) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Port.Merge(m, src)
}
func (m *Port) XXX_Size() int {
	return m.Size()
}
func (m *Port) XXX_DiscardUnknown() {
	xxx_messageInfo_Port.DiscardUnknown(m)
}

var xxx_messageInfo_Port proto.InternalMessageInfo

func (m *Port) GetID() PortID {
	if m != nil {
		return m.ID
	}
	return ""
}

func (m *Port) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *Port) GetNumber() uint32 {
	if m != nil {
		return m.Number
	}
	return 0
}

func (m *Port) GetInternalNumber() uint32 {
	if m != nil {
		return m.InternalNumber
	}
	return 0
}

func (m *Port) GetSpeed() string {
	if m != nil {
		return m.Speed
	}
	return ""
}

func (m *Port) GetEnabled() bool {
	if m != nil {
		return m.Enabled
	}
	return false
}

// PipelineInfo provides information about the currently deployed forwarding pipeline
type PipelineInfo struct {
	Cookie uint64 `protobuf:"varint,1,opt,name=cookie,proto3" json:"cookie,omitempty"`
	P4Info []byte `protobuf:"bytes,2,opt,name=p4_info,json=p4Info,proto3" json:"p4_info,omitempty"`
	// summary information about tables, counters, meters, groups, etc.
	Tables          []*EntitiesInfo `protobuf:"bytes,3,rep,name=tables,proto3" json:"tables,omitempty"`
	Counters        []*EntitiesInfo `protobuf:"bytes,4,rep,name=counters,proto3" json:"counters,omitempty"`
	Meters          []*EntitiesInfo `protobuf:"bytes,5,rep,name=meters,proto3" json:"meters,omitempty"`
	Groups          []*EntitiesInfo `protobuf:"bytes,6,rep,name=groups,proto3" json:"groups,omitempty"`
	MulticastGroups []*EntitiesInfo `protobuf:"bytes,7,rep,name=multicast_groups,json=multicastGroups,proto3" json:"multicast_groups,omitempty"`
	CloneSessions   []*EntitiesInfo `protobuf:"bytes,8,rep,name=clone_sessions,json=cloneSessions,proto3" json:"clone_sessions,omitempty"`
}

func (m *PipelineInfo) Reset()         { *m = PipelineInfo{} }
func (m *PipelineInfo) String() string { return proto.CompactTextString(m) }
func (*PipelineInfo) ProtoMessage()    {}
func (*PipelineInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_7db16019df22577e, []int{2}
}
func (m *PipelineInfo) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *PipelineInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_PipelineInfo.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *PipelineInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PipelineInfo.Merge(m, src)
}
func (m *PipelineInfo) XXX_Size() int {
	return m.Size()
}
func (m *PipelineInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_PipelineInfo.DiscardUnknown(m)
}

var xxx_messageInfo_PipelineInfo proto.InternalMessageInfo

func (m *PipelineInfo) GetCookie() uint64 {
	if m != nil {
		return m.Cookie
	}
	return 0
}

func (m *PipelineInfo) GetP4Info() []byte {
	if m != nil {
		return m.P4Info
	}
	return nil
}

func (m *PipelineInfo) GetTables() []*EntitiesInfo {
	if m != nil {
		return m.Tables
	}
	return nil
}

func (m *PipelineInfo) GetCounters() []*EntitiesInfo {
	if m != nil {
		return m.Counters
	}
	return nil
}

func (m *PipelineInfo) GetMeters() []*EntitiesInfo {
	if m != nil {
		return m.Meters
	}
	return nil
}

func (m *PipelineInfo) GetGroups() []*EntitiesInfo {
	if m != nil {
		return m.Groups
	}
	return nil
}

func (m *PipelineInfo) GetMulticastGroups() []*EntitiesInfo {
	if m != nil {
		return m.MulticastGroups
	}
	return nil
}

func (m *PipelineInfo) GetCloneSessions() []*EntitiesInfo {
	if m != nil {
		return m.CloneSessions
	}
	return nil
}

// EntitiesInfo provides information about size of pipeline entities, tables, meters, counters
type EntitiesInfo struct {
	ID    uint32 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
	Size_ uint32 `protobuf:"varint,2,opt,name=size,proto3" json:"size,omitempty"`
	Name  string `protobuf:"bytes,3,opt,name=name,proto3" json:"name,omitempty"`
}

func (m *EntitiesInfo) Reset()         { *m = EntitiesInfo{} }
func (m *EntitiesInfo) String() string { return proto.CompactTextString(m) }
func (*EntitiesInfo) ProtoMessage()    {}
func (*EntitiesInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_7db16019df22577e, []int{3}
}
func (m *EntitiesInfo) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *EntitiesInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_EntitiesInfo.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *EntitiesInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_EntitiesInfo.Merge(m, src)
}
func (m *EntitiesInfo) XXX_Size() int {
	return m.Size()
}
func (m *EntitiesInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_EntitiesInfo.DiscardUnknown(m)
}

var xxx_messageInfo_EntitiesInfo proto.InternalMessageInfo

func (m *EntitiesInfo) GetID() uint32 {
	if m != nil {
		return m.ID
	}
	return 0
}

func (m *EntitiesInfo) GetSize_() uint32 {
	if m != nil {
		return m.Size_
	}
	return 0
}

func (m *EntitiesInfo) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

type GetDevicesRequest struct {
}

func (m *GetDevicesRequest) Reset()         { *m = GetDevicesRequest{} }
func (m *GetDevicesRequest) String() string { return proto.CompactTextString(m) }
func (*GetDevicesRequest) ProtoMessage()    {}
func (*GetDevicesRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_7db16019df22577e, []int{4}
}
func (m *GetDevicesRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GetDevicesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GetDevicesRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *GetDevicesRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetDevicesRequest.Merge(m, src)
}
func (m *GetDevicesRequest) XXX_Size() int {
	return m.Size()
}
func (m *GetDevicesRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_GetDevicesRequest.DiscardUnknown(m)
}

var xxx_messageInfo_GetDevicesRequest proto.InternalMessageInfo

type GetDevicesResponse struct {
	Devices []*Device `protobuf:"bytes,1,rep,name=devices,proto3" json:"devices,omitempty"`
}

func (m *GetDevicesResponse) Reset()         { *m = GetDevicesResponse{} }
func (m *GetDevicesResponse) String() string { return proto.CompactTextString(m) }
func (*GetDevicesResponse) ProtoMessage()    {}
func (*GetDevicesResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_7db16019df22577e, []int{5}
}
func (m *GetDevicesResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GetDevicesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GetDevicesResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *GetDevicesResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetDevicesResponse.Merge(m, src)
}
func (m *GetDevicesResponse) XXX_Size() int {
	return m.Size()
}
func (m *GetDevicesResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_GetDevicesResponse.DiscardUnknown(m)
}

var xxx_messageInfo_GetDevicesResponse proto.InternalMessageInfo

func (m *GetDevicesResponse) GetDevices() []*Device {
	if m != nil {
		return m.Devices
	}
	return nil
}

type GetDeviceRequest struct {
	ID DeviceID `protobuf:"bytes,1,opt,name=id,proto3,casttype=DeviceID" json:"id,omitempty"`
}

func (m *GetDeviceRequest) Reset()         { *m = GetDeviceRequest{} }
func (m *GetDeviceRequest) String() string { return proto.CompactTextString(m) }
func (*GetDeviceRequest) ProtoMessage()    {}
func (*GetDeviceRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_7db16019df22577e, []int{6}
}
func (m *GetDeviceRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GetDeviceRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GetDeviceRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *GetDeviceRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetDeviceRequest.Merge(m, src)
}
func (m *GetDeviceRequest) XXX_Size() int {
	return m.Size()
}
func (m *GetDeviceRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_GetDeviceRequest.DiscardUnknown(m)
}

var xxx_messageInfo_GetDeviceRequest proto.InternalMessageInfo

func (m *GetDeviceRequest) GetID() DeviceID {
	if m != nil {
		return m.ID
	}
	return ""
}

type GetDeviceResponse struct {
	Device *Device `protobuf:"bytes,1,opt,name=device,proto3" json:"device,omitempty"`
}

func (m *GetDeviceResponse) Reset()         { *m = GetDeviceResponse{} }
func (m *GetDeviceResponse) String() string { return proto.CompactTextString(m) }
func (*GetDeviceResponse) ProtoMessage()    {}
func (*GetDeviceResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_7db16019df22577e, []int{7}
}
func (m *GetDeviceResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GetDeviceResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GetDeviceResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *GetDeviceResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetDeviceResponse.Merge(m, src)
}
func (m *GetDeviceResponse) XXX_Size() int {
	return m.Size()
}
func (m *GetDeviceResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_GetDeviceResponse.DiscardUnknown(m)
}

var xxx_messageInfo_GetDeviceResponse proto.InternalMessageInfo

func (m *GetDeviceResponse) GetDevice() *Device {
	if m != nil {
		return m.Device
	}
	return nil
}

type AddDeviceRequest struct {
	Device *Device `protobuf:"bytes,1,opt,name=device,proto3" json:"device,omitempty"`
}

func (m *AddDeviceRequest) Reset()         { *m = AddDeviceRequest{} }
func (m *AddDeviceRequest) String() string { return proto.CompactTextString(m) }
func (*AddDeviceRequest) ProtoMessage()    {}
func (*AddDeviceRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_7db16019df22577e, []int{8}
}
func (m *AddDeviceRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AddDeviceRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_AddDeviceRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *AddDeviceRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AddDeviceRequest.Merge(m, src)
}
func (m *AddDeviceRequest) XXX_Size() int {
	return m.Size()
}
func (m *AddDeviceRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_AddDeviceRequest.DiscardUnknown(m)
}

var xxx_messageInfo_AddDeviceRequest proto.InternalMessageInfo

func (m *AddDeviceRequest) GetDevice() *Device {
	if m != nil {
		return m.Device
	}
	return nil
}

type AddDeviceResponse struct {
}

func (m *AddDeviceResponse) Reset()         { *m = AddDeviceResponse{} }
func (m *AddDeviceResponse) String() string { return proto.CompactTextString(m) }
func (*AddDeviceResponse) ProtoMessage()    {}
func (*AddDeviceResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_7db16019df22577e, []int{9}
}
func (m *AddDeviceResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AddDeviceResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_AddDeviceResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *AddDeviceResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AddDeviceResponse.Merge(m, src)
}
func (m *AddDeviceResponse) XXX_Size() int {
	return m.Size()
}
func (m *AddDeviceResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_AddDeviceResponse.DiscardUnknown(m)
}

var xxx_messageInfo_AddDeviceResponse proto.InternalMessageInfo

type RemoveDeviceRequest struct {
	ID DeviceID `protobuf:"bytes,1,opt,name=id,proto3,casttype=DeviceID" json:"id,omitempty"`
}

func (m *RemoveDeviceRequest) Reset()         { *m = RemoveDeviceRequest{} }
func (m *RemoveDeviceRequest) String() string { return proto.CompactTextString(m) }
func (*RemoveDeviceRequest) ProtoMessage()    {}
func (*RemoveDeviceRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_7db16019df22577e, []int{10}
}
func (m *RemoveDeviceRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RemoveDeviceRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RemoveDeviceRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RemoveDeviceRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RemoveDeviceRequest.Merge(m, src)
}
func (m *RemoveDeviceRequest) XXX_Size() int {
	return m.Size()
}
func (m *RemoveDeviceRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RemoveDeviceRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RemoveDeviceRequest proto.InternalMessageInfo

func (m *RemoveDeviceRequest) GetID() DeviceID {
	if m != nil {
		return m.ID
	}
	return ""
}

type RemoveDeviceResponse struct {
}

func (m *RemoveDeviceResponse) Reset()         { *m = RemoveDeviceResponse{} }
func (m *RemoveDeviceResponse) String() string { return proto.CompactTextString(m) }
func (*RemoveDeviceResponse) ProtoMessage()    {}
func (*RemoveDeviceResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_7db16019df22577e, []int{11}
}
func (m *RemoveDeviceResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RemoveDeviceResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RemoveDeviceResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RemoveDeviceResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RemoveDeviceResponse.Merge(m, src)
}
func (m *RemoveDeviceResponse) XXX_Size() int {
	return m.Size()
}
func (m *RemoveDeviceResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RemoveDeviceResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RemoveDeviceResponse proto.InternalMessageInfo

type StopDeviceRequest struct {
	ID   DeviceID `protobuf:"bytes,1,opt,name=id,proto3,casttype=DeviceID" json:"id,omitempty"`
	Mode StopMode `protobuf:"varint,2,opt,name=mode,proto3,enum=onos.fabricsim.StopMode" json:"mode,omitempty"`
}

func (m *StopDeviceRequest) Reset()         { *m = StopDeviceRequest{} }
func (m *StopDeviceRequest) String() string { return proto.CompactTextString(m) }
func (*StopDeviceRequest) ProtoMessage()    {}
func (*StopDeviceRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_7db16019df22577e, []int{12}
}
func (m *StopDeviceRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *StopDeviceRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_StopDeviceRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *StopDeviceRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_StopDeviceRequest.Merge(m, src)
}
func (m *StopDeviceRequest) XXX_Size() int {
	return m.Size()
}
func (m *StopDeviceRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_StopDeviceRequest.DiscardUnknown(m)
}

var xxx_messageInfo_StopDeviceRequest proto.InternalMessageInfo

func (m *StopDeviceRequest) GetID() DeviceID {
	if m != nil {
		return m.ID
	}
	return ""
}

func (m *StopDeviceRequest) GetMode() StopMode {
	if m != nil {
		return m.Mode
	}
	return StopMode_ORDERLY_STOP
}

type StopDeviceResponse struct {
}

func (m *StopDeviceResponse) Reset()         { *m = StopDeviceResponse{} }
func (m *StopDeviceResponse) String() string { return proto.CompactTextString(m) }
func (*StopDeviceResponse) ProtoMessage()    {}
func (*StopDeviceResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_7db16019df22577e, []int{13}
}
func (m *StopDeviceResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *StopDeviceResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_StopDeviceResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *StopDeviceResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_StopDeviceResponse.Merge(m, src)
}
func (m *StopDeviceResponse) XXX_Size() int {
	return m.Size()
}
func (m *StopDeviceResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_StopDeviceResponse.DiscardUnknown(m)
}

var xxx_messageInfo_StopDeviceResponse proto.InternalMessageInfo

type StartDeviceRequest struct {
	ID DeviceID `protobuf:"bytes,1,opt,name=id,proto3,casttype=DeviceID" json:"id,omitempty"`
}

func (m *StartDeviceRequest) Reset()         { *m = StartDeviceRequest{} }
func (m *StartDeviceRequest) String() string { return proto.CompactTextString(m) }
func (*StartDeviceRequest) ProtoMessage()    {}
func (*StartDeviceRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_7db16019df22577e, []int{14}
}
func (m *StartDeviceRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *StartDeviceRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_StartDeviceRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *StartDeviceRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_StartDeviceRequest.Merge(m, src)
}
func (m *StartDeviceRequest) XXX_Size() int {
	return m.Size()
}
func (m *StartDeviceRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_StartDeviceRequest.DiscardUnknown(m)
}

var xxx_messageInfo_StartDeviceRequest proto.InternalMessageInfo

func (m *StartDeviceRequest) GetID() DeviceID {
	if m != nil {
		return m.ID
	}
	return ""
}

type StartDeviceResponse struct {
}

func (m *StartDeviceResponse) Reset()         { *m = StartDeviceResponse{} }
func (m *StartDeviceResponse) String() string { return proto.CompactTextString(m) }
func (*StartDeviceResponse) ProtoMessage()    {}
func (*StartDeviceResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_7db16019df22577e, []int{15}
}
func (m *StartDeviceResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *StartDeviceResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_StartDeviceResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *StartDeviceResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_StartDeviceResponse.Merge(m, src)
}
func (m *StartDeviceResponse) XXX_Size() int {
	return m.Size()
}
func (m *StartDeviceResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_StartDeviceResponse.DiscardUnknown(m)
}

var xxx_messageInfo_StartDeviceResponse proto.InternalMessageInfo

type DisablePortRequest struct {
	ID   PortID   `protobuf:"bytes,1,opt,name=id,proto3,casttype=PortID" json:"id,omitempty"`
	Mode StopMode `protobuf:"varint,2,opt,name=mode,proto3,enum=onos.fabricsim.StopMode" json:"mode,omitempty"`
}

func (m *DisablePortRequest) Reset()         { *m = DisablePortRequest{} }
func (m *DisablePortRequest) String() string { return proto.CompactTextString(m) }
func (*DisablePortRequest) ProtoMessage()    {}
func (*DisablePortRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_7db16019df22577e, []int{16}
}
func (m *DisablePortRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DisablePortRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DisablePortRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *DisablePortRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DisablePortRequest.Merge(m, src)
}
func (m *DisablePortRequest) XXX_Size() int {
	return m.Size()
}
func (m *DisablePortRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_DisablePortRequest.DiscardUnknown(m)
}

var xxx_messageInfo_DisablePortRequest proto.InternalMessageInfo

func (m *DisablePortRequest) GetID() PortID {
	if m != nil {
		return m.ID
	}
	return ""
}

func (m *DisablePortRequest) GetMode() StopMode {
	if m != nil {
		return m.Mode
	}
	return StopMode_ORDERLY_STOP
}

type DisablePortResponse struct {
}

func (m *DisablePortResponse) Reset()         { *m = DisablePortResponse{} }
func (m *DisablePortResponse) String() string { return proto.CompactTextString(m) }
func (*DisablePortResponse) ProtoMessage()    {}
func (*DisablePortResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_7db16019df22577e, []int{17}
}
func (m *DisablePortResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DisablePortResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DisablePortResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *DisablePortResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DisablePortResponse.Merge(m, src)
}
func (m *DisablePortResponse) XXX_Size() int {
	return m.Size()
}
func (m *DisablePortResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_DisablePortResponse.DiscardUnknown(m)
}

var xxx_messageInfo_DisablePortResponse proto.InternalMessageInfo

type EnablePortRequest struct {
	ID PortID `protobuf:"bytes,1,opt,name=id,proto3,casttype=PortID" json:"id,omitempty"`
}

func (m *EnablePortRequest) Reset()         { *m = EnablePortRequest{} }
func (m *EnablePortRequest) String() string { return proto.CompactTextString(m) }
func (*EnablePortRequest) ProtoMessage()    {}
func (*EnablePortRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_7db16019df22577e, []int{18}
}
func (m *EnablePortRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *EnablePortRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_EnablePortRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *EnablePortRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_EnablePortRequest.Merge(m, src)
}
func (m *EnablePortRequest) XXX_Size() int {
	return m.Size()
}
func (m *EnablePortRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_EnablePortRequest.DiscardUnknown(m)
}

var xxx_messageInfo_EnablePortRequest proto.InternalMessageInfo

func (m *EnablePortRequest) GetID() PortID {
	if m != nil {
		return m.ID
	}
	return ""
}

type EnablePortResponse struct {
}

func (m *EnablePortResponse) Reset()         { *m = EnablePortResponse{} }
func (m *EnablePortResponse) String() string { return proto.CompactTextString(m) }
func (*EnablePortResponse) ProtoMessage()    {}
func (*EnablePortResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_7db16019df22577e, []int{19}
}
func (m *EnablePortResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *EnablePortResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_EnablePortResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *EnablePortResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_EnablePortResponse.Merge(m, src)
}
func (m *EnablePortResponse) XXX_Size() int {
	return m.Size()
}
func (m *EnablePortResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_EnablePortResponse.DiscardUnknown(m)
}

var xxx_messageInfo_EnablePortResponse proto.InternalMessageInfo

type EmitLLDPPacketRequest struct {
	PortID PortID `protobuf:"bytes,1,opt,name=port_id,json=portId,proto3,casttype=PortID" json:"port_id,omitempty"`
	Packet []byte `protobuf:"bytes,2,opt,name=packet,proto3" json:"packet,omitempty"`
}

func (m *EmitLLDPPacketRequest) Reset()         { *m = EmitLLDPPacketRequest{} }
func (m *EmitLLDPPacketRequest) String() string { return proto.CompactTextString(m) }
func (*EmitLLDPPacketRequest) ProtoMessage()    {}
func (*EmitLLDPPacketRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_7db16019df22577e, []int{20}
}
func (m *EmitLLDPPacketRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *EmitLLDPPacketRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_EmitLLDPPacketRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *EmitLLDPPacketRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_EmitLLDPPacketRequest.Merge(m, src)
}
func (m *EmitLLDPPacketRequest) XXX_Size() int {
	return m.Size()
}
func (m *EmitLLDPPacketRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_EmitLLDPPacketRequest.DiscardUnknown(m)
}

var xxx_messageInfo_EmitLLDPPacketRequest proto.InternalMessageInfo

func (m *EmitLLDPPacketRequest) GetPortID() PortID {
	if m != nil {
		return m.PortID
	}
	return ""
}

func (m *EmitLLDPPacketRequest) GetPacket() []byte {
	if m != nil {
		return m.Packet
	}
	return nil
}

type EmitLLDPPacketResponse struct {
}

func (m *EmitLLDPPacketResponse) Reset()         { *m = EmitLLDPPacketResponse{} }
func (m *EmitLLDPPacketResponse) String() string { return proto.CompactTextString(m) }
func (*EmitLLDPPacketResponse) ProtoMessage()    {}
func (*EmitLLDPPacketResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_7db16019df22577e, []int{21}
}
func (m *EmitLLDPPacketResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *EmitLLDPPacketResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_EmitLLDPPacketResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *EmitLLDPPacketResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_EmitLLDPPacketResponse.Merge(m, src)
}
func (m *EmitLLDPPacketResponse) XXX_Size() int {
	return m.Size()
}
func (m *EmitLLDPPacketResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_EmitLLDPPacketResponse.DiscardUnknown(m)
}

var xxx_messageInfo_EmitLLDPPacketResponse proto.InternalMessageInfo

func init() {
	proto.RegisterEnum("onos.fabricsim.DeviceType", DeviceType_name, DeviceType_value)
	proto.RegisterEnum("onos.fabricsim.StopMode", StopMode_name, StopMode_value)
	proto.RegisterType((*Device)(nil), "onos.fabricsim.Device")
	proto.RegisterType((*Port)(nil), "onos.fabricsim.Port")
	proto.RegisterType((*PipelineInfo)(nil), "onos.fabricsim.PipelineInfo")
	proto.RegisterType((*EntitiesInfo)(nil), "onos.fabricsim.EntitiesInfo")
	proto.RegisterType((*GetDevicesRequest)(nil), "onos.fabricsim.GetDevicesRequest")
	proto.RegisterType((*GetDevicesResponse)(nil), "onos.fabricsim.GetDevicesResponse")
	proto.RegisterType((*GetDeviceRequest)(nil), "onos.fabricsim.GetDeviceRequest")
	proto.RegisterType((*GetDeviceResponse)(nil), "onos.fabricsim.GetDeviceResponse")
	proto.RegisterType((*AddDeviceRequest)(nil), "onos.fabricsim.AddDeviceRequest")
	proto.RegisterType((*AddDeviceResponse)(nil), "onos.fabricsim.AddDeviceResponse")
	proto.RegisterType((*RemoveDeviceRequest)(nil), "onos.fabricsim.RemoveDeviceRequest")
	proto.RegisterType((*RemoveDeviceResponse)(nil), "onos.fabricsim.RemoveDeviceResponse")
	proto.RegisterType((*StopDeviceRequest)(nil), "onos.fabricsim.StopDeviceRequest")
	proto.RegisterType((*StopDeviceResponse)(nil), "onos.fabricsim.StopDeviceResponse")
	proto.RegisterType((*StartDeviceRequest)(nil), "onos.fabricsim.StartDeviceRequest")
	proto.RegisterType((*StartDeviceResponse)(nil), "onos.fabricsim.StartDeviceResponse")
	proto.RegisterType((*DisablePortRequest)(nil), "onos.fabricsim.DisablePortRequest")
	proto.RegisterType((*DisablePortResponse)(nil), "onos.fabricsim.DisablePortResponse")
	proto.RegisterType((*EnablePortRequest)(nil), "onos.fabricsim.EnablePortRequest")
	proto.RegisterType((*EnablePortResponse)(nil), "onos.fabricsim.EnablePortResponse")
	proto.RegisterType((*EmitLLDPPacketRequest)(nil), "onos.fabricsim.EmitLLDPPacketRequest")
	proto.RegisterType((*EmitLLDPPacketResponse)(nil), "onos.fabricsim.EmitLLDPPacketResponse")
}

func init() { proto.RegisterFile("onos/fabricsim/devices.proto", fileDescriptor_7db16019df22577e) }

var fileDescriptor_7db16019df22577e = []byte{
	// 1099 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x56, 0x4f, 0x73, 0xda, 0x46,
	0x14, 0xb7, 0x0c, 0x08, 0x78, 0x06, 0x07, 0xaf, 0xb1, 0xa3, 0x61, 0x32, 0x18, 0x2b, 0xfd, 0x43,
	0xd3, 0x94, 0x74, 0x5c, 0xb7, 0x4d, 0x7b, 0x33, 0xe0, 0x3a, 0xcc, 0xb8, 0x31, 0xb3, 0xb8, 0xed,
	0xe4, 0x52, 0x0d, 0x96, 0xd6, 0xee, 0x4e, 0x40, 0xab, 0x6a, 0xe5, 0xcc, 0xa4, 0x9f, 0xa2, 0x9f,
	0xa0, 0xf7, 0x1e, 0xfa, 0x3d, 0x7a, 0xcc, 0xb1, 0x27, 0x4f, 0x07, 0x9f, 0xfa, 0x15, 0x7a, 0xea,
	0xec, 0x1f, 0x84, 0x40, 0xc4, 0xb1, 0x7b, 0x61, 0xb4, 0x6f, 0x7f, 0xbf, 0xdf, 0x5b, 0xbd, 0xb7,
	0xbf, 0x27, 0xe0, 0x01, 0xf3, 0x19, 0x7f, 0x72, 0x3e, 0x3c, 0x0b, 0xa9, 0xcb, 0xe9, 0xf8, 0x89,
	0x47, 0x5e, 0x51, 0x97, 0xf0, 0x56, 0x10, 0xb2, 0x88, 0xa1, 0x75, 0xb1, 0xdb, 0x8a, 0x77, 0x6b,
	0xd5, 0x0b, 0x76, 0xc1, 0xe4, 0xd6, 0x13, 0xf1, 0xa4, 0x50, 0xb5, 0xaa, 0xd4, 0x18, 0x53, 0xee,
	0xca, 0x1f, 0x15, 0xb5, 0xff, 0xc9, 0x80, 0xd9, 0x95, 0x6a, 0xc8, 0x86, 0x55, 0xea, 0x59, 0x46,
	0xc3, 0x68, 0x16, 0xdb, 0x68, 0x72, 0xb5, 0xb3, 0xda, 0xeb, 0xfe, 0x7b, 0xb5, 0x53, 0x50, 0xbb,
	0xbd, 0x2e, 0x5e, 0xa5, 0x1e, 0x6a, 0x41, 0x36, 0x7a, 0x1d, 0x10, 0x6b, 0xb5, 0x61, 0x34, 0xd7,
	0xf7, 0x6a, 0xad, 0xf9, 0xcc, 0x2d, 0x85, 0x3d, 0x7d, 0x1d, 0x10, 0x2c, 0x71, 0xe8, 0x11, 0xe4,
	0x02, 0x16, 0x46, 0xdc, 0xca, 0x34, 0x32, 0xcd, 0xb5, 0xbd, 0xea, 0x22, 0xa1, 0xcf, 0xc2, 0x08,
	0x2b, 0x08, 0xda, 0x85, 0x92, 0xcb, 0xfc, 0x28, 0x64, 0x23, 0x47, 0x04, 0xac, 0x6c, 0xc3, 0x68,
	0xe6, 0xf0, 0x9a, 0x8e, 0x09, 0x24, 0x7a, 0x0c, 0xe0, 0xfe, 0x34, 0xe4, 0x9c, 0x72, 0x87, 0x7a,
	0x56, 0xae, 0x61, 0x34, 0xb3, 0xed, 0xf2, 0xe4, 0x6a, 0xa7, 0xd8, 0x51, 0xd1, 0x5e, 0x17, 0x17,
	0x35, 0xa0, 0xe7, 0xa1, 0x03, 0x28, 0x07, 0x34, 0x20, 0x23, 0xea, 0x13, 0x87, 0xfa, 0xe7, 0xcc,
	0x32, 0x1b, 0x46, 0x73, 0x6d, 0xef, 0x41, 0xea, 0x10, 0x1a, 0xd4, 0xf3, 0xcf, 0x19, 0x2e, 0x05,
	0x89, 0x15, 0xfa, 0x08, 0x32, 0x01, 0xe3, 0x56, 0x5e, 0x12, 0xef, 0x2b, 0xa2, 0xac, 0xde, 0x51,
	0x48, 0xbd, 0x3e, 0xe3, 0x34, 0xa2, 0xcc, 0xc7, 0x02, 0x83, 0xbe, 0x04, 0x71, 0x54, 0x9f, 0xb8,
	0x22, 0xc4, 0xad, 0x82, 0x7c, 0xe1, 0xad, 0x04, 0xa5, 0x13, 0xef, 0xe2, 0x24, 0x12, 0x7d, 0x0c,
	0x1b, 0x11, 0x8b, 0x86, 0x23, 0x27, 0x49, 0x2f, 0xca, 0x97, 0xaf, 0xc8, 0x8d, 0x4e, 0x02, 0xfc,
	0x35, 0x14, 0x28, 0x73, 0x78, 0x34, 0x8c, 0xb8, 0x05, 0xf2, 0x54, 0x28, 0x91, 0xa2, 0x77, 0x32,
	0x10, 0x3b, 0xed, 0xb5, 0xc9, 0xd5, 0x4e, 0x5e, 0x2f, 0x70, 0x9e, 0x32, 0xf9, 0x60, 0xff, 0x61,
	0x40, 0x56, 0x96, 0xb1, 0x91, 0xe8, 0x74, 0x25, 0xee, 0xb4, 0x29, 0xf6, 0x74, 0x9f, 0x11, 0x64,
	0xfd, 0xe1, 0x98, 0x58, 0x19, 0x81, 0xc1, 0xf2, 0x19, 0x6d, 0x83, 0xe9, 0x5f, 0x8e, 0xcf, 0x48,
	0x28, 0x3b, 0x53, 0xc6, 0x7a, 0x85, 0x3e, 0x84, 0x7b, 0xd4, 0x8f, 0x48, 0xe8, 0x0f, 0x47, 0x8e,
	0x06, 0xe4, 0x24, 0x60, 0x7d, 0x1a, 0x7e, 0xae, 0x80, 0x55, 0xc8, 0xf1, 0x80, 0x10, 0x4f, 0xf6,
	0xa1, 0x88, 0xd5, 0x02, 0x59, 0x90, 0x27, 0xfe, 0xf0, 0x6c, 0x44, 0x3c, 0x59, 0xe6, 0x02, 0x9e,
	0x2e, 0xed, 0xdf, 0x33, 0x50, 0x4a, 0xf6, 0x46, 0x9c, 0xc0, 0x65, 0xec, 0x25, 0x25, 0xf2, 0xec,
	0x59, 0xac, 0x57, 0xe8, 0x3e, 0xe4, 0x83, 0x7d, 0xd5, 0x62, 0x71, 0x31, 0x4b, 0xd8, 0x0c, 0xf6,
	0x25, 0x61, 0x1f, 0xcc, 0x48, 0x68, 0x4d, 0xef, 0x5f, 0xaa, 0xf5, 0x87, 0x7e, 0x44, 0x23, 0x4a,
	0xb8, 0x6c, 0xbd, 0xc6, 0xa2, 0xa7, 0x50, 0x70, 0xd9, 0xa5, 0x38, 0x3b, 0xb7, 0xb2, 0xb7, 0xe0,
	0xc5, 0x68, 0x91, 0x6f, 0x4c, 0x24, 0x2f, 0x77, 0x9b, 0x7c, 0x0a, 0x2b, 0x58, 0x17, 0x21, 0xbb,
	0x0c, 0xb8, 0x65, 0xde, 0x86, 0xa5, 0xb0, 0xe8, 0x08, 0x2a, 0xe3, 0xcb, 0x51, 0x44, 0xdd, 0x21,
	0x8f, 0x1c, 0xcd, 0xcf, 0xdf, 0x82, 0x7f, 0x2f, 0x66, 0x1d, 0x29, 0xa1, 0x0e, 0xac, 0xbb, 0x23,
	0xe6, 0x13, 0x87, 0x13, 0xce, 0x13, 0x77, 0xf7, 0x66, 0x99, 0xb2, 0xe4, 0x0c, 0x34, 0xc5, 0x7e,
	0x0e, 0xa5, 0xe4, 0x36, 0xda, 0x8e, 0xaf, 0x58, 0xb9, 0x6d, 0xaa, 0x2b, 0x36, 0xbd, 0x58, 0x9c,
	0xfe, 0xa2, 0x06, 0x48, 0x19, 0xcb, 0xe7, 0x65, 0x97, 0xcd, 0xde, 0x84, 0x8d, 0x23, 0x12, 0xa9,
	0x79, 0xc2, 0x31, 0xf9, 0xf9, 0x92, 0xf0, 0xc8, 0xfe, 0x06, 0x50, 0x32, 0xc8, 0x03, 0xe6, 0x73,
	0x82, 0x3e, 0x85, 0xbc, 0x9e, 0x87, 0x96, 0x21, 0x0f, 0xbe, 0xbd, 0x7c, 0x2c, 0xe1, 0x29, 0xcc,
	0xfe, 0x02, 0x2a, 0xb1, 0x8e, 0xd6, 0xbe, 0xcd, 0xf4, 0xb3, 0x3b, 0x89, 0x43, 0xc5, 0xe9, 0x5b,
	0x60, 0x2a, 0x5d, 0x49, 0x7e, 0x7b, 0x76, 0x8d, 0xb2, 0xdb, 0x50, 0x39, 0xf0, 0xbc, 0xf9, 0xe4,
	0x77, 0xd5, 0xd8, 0x84, 0x8d, 0x84, 0x86, 0x3a, 0x88, 0xfd, 0x15, 0x6c, 0x62, 0x32, 0x66, 0xaf,
	0xc8, 0xdd, 0x5f, 0x6c, 0x1b, 0xaa, 0xf3, 0x54, 0x2d, 0x49, 0x60, 0x63, 0x10, 0xb1, 0xe0, 0xce,
	0x82, 0xe8, 0x31, 0x64, 0xc7, 0xcc, 0x9b, 0x7e, 0x27, 0xac, 0xc5, 0xd7, 0x11, 0xa2, 0xdf, 0x32,
	0x8f, 0x60, 0x89, 0xb2, 0xab, 0x80, 0x92, 0x69, 0x74, 0xf2, 0xa7, 0x22, 0x3a, 0x0c, 0xff, 0x47,
	0x9f, 0xb6, 0x60, 0x73, 0x8e, 0xa9, 0x05, 0x3d, 0x40, 0x5d, 0xca, 0x85, 0xc7, 0xe5, 0x67, 0x47,
	0x0b, 0xbe, 0x7b, 0x18, 0xde, 0xed, 0x65, 0xb6, 0x60, 0x73, 0x2e, 0x8b, 0x4e, 0xfe, 0x39, 0x6c,
	0x1c, 0xfa, 0x77, 0xce, 0x2d, 0x4a, 0x93, 0xa4, 0x69, 0xb1, 0x1f, 0x61, 0xeb, 0x70, 0x4c, 0xa3,
	0xe3, 0xe3, 0x6e, 0xbf, 0x3f, 0x74, 0x5f, 0x92, 0x58, 0xf0, 0x13, 0xc8, 0x8b, 0x6f, 0xa7, 0x13,
	0xab, 0x56, 0x27, 0xb1, 0x5e, 0x42, 0xd9, 0x14, 0xa0, 0x9e, 0x27, 0x06, 0x6a, 0x20, 0xf9, 0xf1,
	0xdc, 0x94, 0x2b, 0xdb, 0x82, 0xed, 0x45, 0x7d, 0x95, 0xf9, 0xd1, 0x2e, 0xc0, 0xec, 0x23, 0x8f,
	0x00, 0xcc, 0xc1, 0x0f, 0xbd, 0xd3, 0xce, 0xb3, 0xca, 0x0a, 0xca, 0x43, 0xa6, 0xd7, 0xff, 0xae,
	0x62, 0x3c, 0x6a, 0x41, 0x61, 0x5a, 0x12, 0x54, 0x81, 0xd2, 0x09, 0xee, 0x1e, 0xe2, 0xe3, 0x17,
	0xce, 0xe0, 0xf4, 0xa4, 0x5f, 0x59, 0x11, 0x91, 0xce, 0xb3, 0x83, 0x93, 0xd3, 0x5e, 0x47, 0x45,
	0x8c, 0xbd, 0xdf, 0x4c, 0x28, 0x2b, 0xcd, 0x01, 0x09, 0xe5, 0x3f, 0x91, 0x01, 0xc0, 0xcc, 0xe7,
	0x68, 0x77, 0xb1, 0xe0, 0xa9, 0xc1, 0x50, 0xb3, 0x6f, 0x82, 0x68, 0x9f, 0xf6, 0xa1, 0x18, 0x47,
	0x51, 0xe3, 0xad, 0x84, 0xa9, 0xe4, 0xee, 0x0d, 0x88, 0x99, 0x62, 0xec, 0xc2, 0xb4, 0xe2, 0xa2,
	0xc9, 0xd3, 0x8a, 0x29, 0x0b, 0xa3, 0x17, 0x50, 0x4a, 0xfa, 0x10, 0x3d, 0x5c, 0xa4, 0x2c, 0x31,
	0x78, 0xed, 0xbd, 0x9b, 0x41, 0x5a, 0x7a, 0x00, 0x30, 0xf3, 0x58, 0xba, 0xa6, 0x29, 0x9b, 0xa7,
	0x6b, 0x9a, 0xb6, 0x28, 0xfa, 0x1e, 0xd6, 0x12, 0x46, 0x43, 0x4b, 0x28, 0x8b, 0xfe, 0xad, 0x3d,
	0xbc, 0x11, 0x33, 0xd3, 0x4d, 0x78, 0x28, 0xad, 0x9b, 0xb6, 0x71, 0x5a, 0x77, 0x89, 0x09, 0x45,
	0x11, 0x66, 0x6e, 0x4a, 0x17, 0x21, 0x65, 0xd0, 0x74, 0x11, 0xd2, 0x66, 0x44, 0x0e, 0xac, 0xcf,
	0x9b, 0x05, 0xbd, 0x9f, 0x62, 0x2d, 0x33, 0x6b, 0xed, 0x83, 0x77, 0xc1, 0x54, 0x82, 0xb6, 0xf5,
	0xe7, 0xa4, 0x6e, 0xbc, 0x99, 0xd4, 0x8d, 0xbf, 0x27, 0x75, 0xe3, 0xd7, 0xeb, 0xfa, 0xca, 0x9b,
	0xeb, 0xfa, 0xca, 0x5f, 0xd7, 0xf5, 0x95, 0x33, 0x53, 0xfe, 0x89, 0xff, 0xec, 0xbf, 0x00, 0x00,
	0x00, 0xff, 0xff, 0x80, 0xa9, 0x39, 0x1e, 0x20, 0x0c, 0x00, 0x00,
}

// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4

// DeviceServiceClient is the client API for DeviceService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type DeviceServiceClient interface {
	// GetDevices gets a list of all simulated devices (switches and/or IPUs)
	GetDevices(ctx context.Context, in *GetDevicesRequest, opts ...grpc.CallOption) (*GetDevicesResponse, error)
	// GetDevice gets a specific device entry
	GetDevice(ctx context.Context, in *GetDeviceRequest, opts ...grpc.CallOption) (*GetDeviceResponse, error)
	// AddDevice creates a new simulated deviceand start its P4Runtime and gNMI services
	AddDevice(ctx context.Context, in *AddDeviceRequest, opts ...grpc.CallOption) (*AddDeviceResponse, error)
	// RemoveDevice removes a simulated device
	RemoveDevice(ctx context.Context, in *RemoveDeviceRequest, opts ...grpc.CallOption) (*RemoveDeviceResponse, error)
	// StopDevice stops the simulated deviceP4Runtime and gNMI services
	StopDevice(ctx context.Context, in *StopDeviceRequest, opts ...grpc.CallOption) (*StopDeviceResponse, error)
	// StartDevice starts the simulated deviceP4Runtime and gNMI services
	StartDevice(ctx context.Context, in *StartDeviceRequest, opts ...grpc.CallOption) (*StartDeviceResponse, error)
	// DisablePort disables the specified port
	DisablePort(ctx context.Context, in *DisablePortRequest, opts ...grpc.CallOption) (*DisablePortResponse, error)
	// EnablePort enables the specified port
	EnablePort(ctx context.Context, in *EnablePortRequest, opts ...grpc.CallOption) (*EnablePortResponse, error)
	// EmitLLDPPacket emits the specified LLDP packet on a given device port.
	EmitLLDPPacket(ctx context.Context, in *EmitLLDPPacketRequest, opts ...grpc.CallOption) (*EmitLLDPPacketResponse, error)
}

type deviceServiceClient struct {
	cc *grpc.ClientConn
}

func NewDeviceServiceClient(cc *grpc.ClientConn) DeviceServiceClient {
	return &deviceServiceClient{cc}
}

func (c *deviceServiceClient) GetDevices(ctx context.Context, in *GetDevicesRequest, opts ...grpc.CallOption) (*GetDevicesResponse, error) {
	out := new(GetDevicesResponse)
	err := c.cc.Invoke(ctx, "/onos.fabricsim.DeviceService/GetDevices", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *deviceServiceClient) GetDevice(ctx context.Context, in *GetDeviceRequest, opts ...grpc.CallOption) (*GetDeviceResponse, error) {
	out := new(GetDeviceResponse)
	err := c.cc.Invoke(ctx, "/onos.fabricsim.DeviceService/GetDevice", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *deviceServiceClient) AddDevice(ctx context.Context, in *AddDeviceRequest, opts ...grpc.CallOption) (*AddDeviceResponse, error) {
	out := new(AddDeviceResponse)
	err := c.cc.Invoke(ctx, "/onos.fabricsim.DeviceService/AddDevice", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *deviceServiceClient) RemoveDevice(ctx context.Context, in *RemoveDeviceRequest, opts ...grpc.CallOption) (*RemoveDeviceResponse, error) {
	out := new(RemoveDeviceResponse)
	err := c.cc.Invoke(ctx, "/onos.fabricsim.DeviceService/RemoveDevice", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *deviceServiceClient) StopDevice(ctx context.Context, in *StopDeviceRequest, opts ...grpc.CallOption) (*StopDeviceResponse, error) {
	out := new(StopDeviceResponse)
	err := c.cc.Invoke(ctx, "/onos.fabricsim.DeviceService/StopDevice", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *deviceServiceClient) StartDevice(ctx context.Context, in *StartDeviceRequest, opts ...grpc.CallOption) (*StartDeviceResponse, error) {
	out := new(StartDeviceResponse)
	err := c.cc.Invoke(ctx, "/onos.fabricsim.DeviceService/StartDevice", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *deviceServiceClient) DisablePort(ctx context.Context, in *DisablePortRequest, opts ...grpc.CallOption) (*DisablePortResponse, error) {
	out := new(DisablePortResponse)
	err := c.cc.Invoke(ctx, "/onos.fabricsim.DeviceService/DisablePort", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *deviceServiceClient) EnablePort(ctx context.Context, in *EnablePortRequest, opts ...grpc.CallOption) (*EnablePortResponse, error) {
	out := new(EnablePortResponse)
	err := c.cc.Invoke(ctx, "/onos.fabricsim.DeviceService/EnablePort", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *deviceServiceClient) EmitLLDPPacket(ctx context.Context, in *EmitLLDPPacketRequest, opts ...grpc.CallOption) (*EmitLLDPPacketResponse, error) {
	out := new(EmitLLDPPacketResponse)
	err := c.cc.Invoke(ctx, "/onos.fabricsim.DeviceService/EmitLLDPPacket", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// DeviceServiceServer is the server API for DeviceService service.
type DeviceServiceServer interface {
	// GetDevices gets a list of all simulated devices (switches and/or IPUs)
	GetDevices(context.Context, *GetDevicesRequest) (*GetDevicesResponse, error)
	// GetDevice gets a specific device entry
	GetDevice(context.Context, *GetDeviceRequest) (*GetDeviceResponse, error)
	// AddDevice creates a new simulated deviceand start its P4Runtime and gNMI services
	AddDevice(context.Context, *AddDeviceRequest) (*AddDeviceResponse, error)
	// RemoveDevice removes a simulated device
	RemoveDevice(context.Context, *RemoveDeviceRequest) (*RemoveDeviceResponse, error)
	// StopDevice stops the simulated deviceP4Runtime and gNMI services
	StopDevice(context.Context, *StopDeviceRequest) (*StopDeviceResponse, error)
	// StartDevice starts the simulated deviceP4Runtime and gNMI services
	StartDevice(context.Context, *StartDeviceRequest) (*StartDeviceResponse, error)
	// DisablePort disables the specified port
	DisablePort(context.Context, *DisablePortRequest) (*DisablePortResponse, error)
	// EnablePort enables the specified port
	EnablePort(context.Context, *EnablePortRequest) (*EnablePortResponse, error)
	// EmitLLDPPacket emits the specified LLDP packet on a given device port.
	EmitLLDPPacket(context.Context, *EmitLLDPPacketRequest) (*EmitLLDPPacketResponse, error)
}

// UnimplementedDeviceServiceServer can be embedded to have forward compatible implementations.
type UnimplementedDeviceServiceServer struct {
}

func (*UnimplementedDeviceServiceServer) GetDevices(ctx context.Context, req *GetDevicesRequest) (*GetDevicesResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetDevices not implemented")
}
func (*UnimplementedDeviceServiceServer) GetDevice(ctx context.Context, req *GetDeviceRequest) (*GetDeviceResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetDevice not implemented")
}
func (*UnimplementedDeviceServiceServer) AddDevice(ctx context.Context, req *AddDeviceRequest) (*AddDeviceResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AddDevice not implemented")
}
func (*UnimplementedDeviceServiceServer) RemoveDevice(ctx context.Context, req *RemoveDeviceRequest) (*RemoveDeviceResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RemoveDevice not implemented")
}
func (*UnimplementedDeviceServiceServer) StopDevice(ctx context.Context, req *StopDeviceRequest) (*StopDeviceResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method StopDevice not implemented")
}
func (*UnimplementedDeviceServiceServer) StartDevice(ctx context.Context, req *StartDeviceRequest) (*StartDeviceResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method StartDevice not implemented")
}
func (*UnimplementedDeviceServiceServer) DisablePort(ctx context.Context, req *DisablePortRequest) (*DisablePortResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DisablePort not implemented")
}
func (*UnimplementedDeviceServiceServer) EnablePort(ctx context.Context, req *EnablePortRequest) (*EnablePortResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method EnablePort not implemented")
}
func (*UnimplementedDeviceServiceServer) EmitLLDPPacket(ctx context.Context, req *EmitLLDPPacketRequest) (*EmitLLDPPacketResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method EmitLLDPPacket not implemented")
}

func RegisterDeviceServiceServer(s *grpc.Server, srv DeviceServiceServer) {
	s.RegisterService(&_DeviceService_serviceDesc, srv)
}

func _DeviceService_GetDevices_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetDevicesRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DeviceServiceServer).GetDevices(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/onos.fabricsim.DeviceService/GetDevices",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DeviceServiceServer).GetDevices(ctx, req.(*GetDevicesRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _DeviceService_GetDevice_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetDeviceRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DeviceServiceServer).GetDevice(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/onos.fabricsim.DeviceService/GetDevice",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DeviceServiceServer).GetDevice(ctx, req.(*GetDeviceRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _DeviceService_AddDevice_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AddDeviceRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DeviceServiceServer).AddDevice(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/onos.fabricsim.DeviceService/AddDevice",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DeviceServiceServer).AddDevice(ctx, req.(*AddDeviceRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _DeviceService_RemoveDevice_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RemoveDeviceRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DeviceServiceServer).RemoveDevice(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/onos.fabricsim.DeviceService/RemoveDevice",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DeviceServiceServer).RemoveDevice(ctx, req.(*RemoveDeviceRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _DeviceService_StopDevice_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(StopDeviceRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DeviceServiceServer).StopDevice(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/onos.fabricsim.DeviceService/StopDevice",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DeviceServiceServer).StopDevice(ctx, req.(*StopDeviceRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _DeviceService_StartDevice_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(StartDeviceRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DeviceServiceServer).StartDevice(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/onos.fabricsim.DeviceService/StartDevice",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DeviceServiceServer).StartDevice(ctx, req.(*StartDeviceRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _DeviceService_DisablePort_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DisablePortRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DeviceServiceServer).DisablePort(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/onos.fabricsim.DeviceService/DisablePort",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DeviceServiceServer).DisablePort(ctx, req.(*DisablePortRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _DeviceService_EnablePort_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(EnablePortRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DeviceServiceServer).EnablePort(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/onos.fabricsim.DeviceService/EnablePort",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DeviceServiceServer).EnablePort(ctx, req.(*EnablePortRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _DeviceService_EmitLLDPPacket_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(EmitLLDPPacketRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DeviceServiceServer).EmitLLDPPacket(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/onos.fabricsim.DeviceService/EmitLLDPPacket",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DeviceServiceServer).EmitLLDPPacket(ctx, req.(*EmitLLDPPacketRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _DeviceService_serviceDesc = grpc.ServiceDesc{
	ServiceName: "onos.fabricsim.DeviceService",
	HandlerType: (*DeviceServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetDevices",
			Handler:    _DeviceService_GetDevices_Handler,
		},
		{
			MethodName: "GetDevice",
			Handler:    _DeviceService_GetDevice_Handler,
		},
		{
			MethodName: "AddDevice",
			Handler:    _DeviceService_AddDevice_Handler,
		},
		{
			MethodName: "RemoveDevice",
			Handler:    _DeviceService_RemoveDevice_Handler,
		},
		{
			MethodName: "StopDevice",
			Handler:    _DeviceService_StopDevice_Handler,
		},
		{
			MethodName: "StartDevice",
			Handler:    _DeviceService_StartDevice_Handler,
		},
		{
			MethodName: "DisablePort",
			Handler:    _DeviceService_DisablePort_Handler,
		},
		{
			MethodName: "EnablePort",
			Handler:    _DeviceService_EnablePort_Handler,
		},
		{
			MethodName: "EmitLLDPPacket",
			Handler:    _DeviceService_EmitLLDPPacket_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "onos/fabricsim/devices.proto",
}

func (m *Device) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Device) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Device) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.IOStats != nil {
		{
			size, err := m.IOStats.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintDevices(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x52
	}
	if m.TotalConnections != 0 {
		i = encodeVarintDevices(dAtA, i, uint64(m.TotalConnections))
		i--
		dAtA[i] = 0x48
	}
	if len(m.Connections) > 0 {
		for iNdEx := len(m.Connections) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Connections[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintDevices(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x42
		}
	}
	if m.Pos != nil {
		{
			size, err := m.Pos.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintDevices(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x3a
	}
	if m.PipelineInfo != nil {
		{
			size, err := m.PipelineInfo.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintDevices(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	if m.ChassisID != 0 {
		i = encodeVarintDevices(dAtA, i, uint64(m.ChassisID))
		i--
		dAtA[i] = 0x28
	}
	if m.ControlPort != 0 {
		i = encodeVarintDevices(dAtA, i, uint64(m.ControlPort))
		i--
		dAtA[i] = 0x20
	}
	if len(m.Ports) > 0 {
		for iNdEx := len(m.Ports) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Ports[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintDevices(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if m.Type != 0 {
		i = encodeVarintDevices(dAtA, i, uint64(m.Type))
		i--
		dAtA[i] = 0x10
	}
	if len(m.ID) > 0 {
		i -= len(m.ID)
		copy(dAtA[i:], m.ID)
		i = encodeVarintDevices(dAtA, i, uint64(len(m.ID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *Port) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Port) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Port) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Enabled {
		i--
		if m.Enabled {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x38
	}
	if len(m.Speed) > 0 {
		i -= len(m.Speed)
		copy(dAtA[i:], m.Speed)
		i = encodeVarintDevices(dAtA, i, uint64(len(m.Speed)))
		i--
		dAtA[i] = 0x32
	}
	if m.InternalNumber != 0 {
		i = encodeVarintDevices(dAtA, i, uint64(m.InternalNumber))
		i--
		dAtA[i] = 0x28
	}
	if m.Number != 0 {
		i = encodeVarintDevices(dAtA, i, uint64(m.Number))
		i--
		dAtA[i] = 0x20
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintDevices(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.ID) > 0 {
		i -= len(m.ID)
		copy(dAtA[i:], m.ID)
		i = encodeVarintDevices(dAtA, i, uint64(len(m.ID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *PipelineInfo) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *PipelineInfo) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *PipelineInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.CloneSessions) > 0 {
		for iNdEx := len(m.CloneSessions) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.CloneSessions[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintDevices(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x42
		}
	}
	if len(m.MulticastGroups) > 0 {
		for iNdEx := len(m.MulticastGroups) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.MulticastGroups[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintDevices(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x3a
		}
	}
	if len(m.Groups) > 0 {
		for iNdEx := len(m.Groups) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Groups[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintDevices(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x32
		}
	}
	if len(m.Meters) > 0 {
		for iNdEx := len(m.Meters) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Meters[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintDevices(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x2a
		}
	}
	if len(m.Counters) > 0 {
		for iNdEx := len(m.Counters) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Counters[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintDevices(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x22
		}
	}
	if len(m.Tables) > 0 {
		for iNdEx := len(m.Tables) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Tables[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintDevices(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.P4Info) > 0 {
		i -= len(m.P4Info)
		copy(dAtA[i:], m.P4Info)
		i = encodeVarintDevices(dAtA, i, uint64(len(m.P4Info)))
		i--
		dAtA[i] = 0x12
	}
	if m.Cookie != 0 {
		i = encodeVarintDevices(dAtA, i, uint64(m.Cookie))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *EntitiesInfo) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *EntitiesInfo) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EntitiesInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintDevices(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0x1a
	}
	if m.Size_ != 0 {
		i = encodeVarintDevices(dAtA, i, uint64(m.Size_))
		i--
		dAtA[i] = 0x10
	}
	if m.ID != 0 {
		i = encodeVarintDevices(dAtA, i, uint64(m.ID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *GetDevicesRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *GetDevicesRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GetDevicesRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *GetDevicesResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *GetDevicesResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GetDevicesResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Devices) > 0 {
		for iNdEx := len(m.Devices) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Devices[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintDevices(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *GetDeviceRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *GetDeviceRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GetDeviceRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ID) > 0 {
		i -= len(m.ID)
		copy(dAtA[i:], m.ID)
		i = encodeVarintDevices(dAtA, i, uint64(len(m.ID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *GetDeviceResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *GetDeviceResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GetDeviceResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Device != nil {
		{
			size, err := m.Device.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintDevices(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *AddDeviceRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *AddDeviceRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AddDeviceRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Device != nil {
		{
			size, err := m.Device.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintDevices(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *AddDeviceResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *AddDeviceResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AddDeviceResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RemoveDeviceRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RemoveDeviceRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RemoveDeviceRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ID) > 0 {
		i -= len(m.ID)
		copy(dAtA[i:], m.ID)
		i = encodeVarintDevices(dAtA, i, uint64(len(m.ID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RemoveDeviceResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RemoveDeviceResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RemoveDeviceResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *StopDeviceRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *StopDeviceRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *StopDeviceRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Mode != 0 {
		i = encodeVarintDevices(dAtA, i, uint64(m.Mode))
		i--
		dAtA[i] = 0x10
	}
	if len(m.ID) > 0 {
		i -= len(m.ID)
		copy(dAtA[i:], m.ID)
		i = encodeVarintDevices(dAtA, i, uint64(len(m.ID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *StopDeviceResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *StopDeviceResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *StopDeviceResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *StartDeviceRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *StartDeviceRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *StartDeviceRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ID) > 0 {
		i -= len(m.ID)
		copy(dAtA[i:], m.ID)
		i = encodeVarintDevices(dAtA, i, uint64(len(m.ID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *StartDeviceResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *StartDeviceResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *StartDeviceResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *DisablePortRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *DisablePortRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DisablePortRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Mode != 0 {
		i = encodeVarintDevices(dAtA, i, uint64(m.Mode))
		i--
		dAtA[i] = 0x10
	}
	if len(m.ID) > 0 {
		i -= len(m.ID)
		copy(dAtA[i:], m.ID)
		i = encodeVarintDevices(dAtA, i, uint64(len(m.ID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *DisablePortResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *DisablePortResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DisablePortResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *EnablePortRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *EnablePortRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EnablePortRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ID) > 0 {
		i -= len(m.ID)
		copy(dAtA[i:], m.ID)
		i = encodeVarintDevices(dAtA, i, uint64(len(m.ID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EnablePortResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *EnablePortResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EnablePortResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *EmitLLDPPacketRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *EmitLLDPPacketRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EmitLLDPPacketRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Packet) > 0 {
		i -= len(m.Packet)
		copy(dAtA[i:], m.Packet)
		i = encodeVarintDevices(dAtA, i, uint64(len(m.Packet)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.PortID) > 0 {
		i -= len(m.PortID)
		copy(dAtA[i:], m.PortID)
		i = encodeVarintDevices(dAtA, i, uint64(len(m.PortID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EmitLLDPPacketResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *EmitLLDPPacketResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EmitLLDPPacketResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func encodeVarintDevices(dAtA []byte, offset int, v uint64) int {
	offset -= sovDevices(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *Device) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ID)
	if l > 0 {
		n += 1 + l + sovDevices(uint64(l))
	}
	if m.Type != 0 {
		n += 1 + sovDevices(uint64(m.Type))
	}
	if len(m.Ports) > 0 {
		for _, e := range m.Ports {
			l = e.Size()
			n += 1 + l + sovDevices(uint64(l))
		}
	}
	if m.ControlPort != 0 {
		n += 1 + sovDevices(uint64(m.ControlPort))
	}
	if m.ChassisID != 0 {
		n += 1 + sovDevices(uint64(m.ChassisID))
	}
	if m.PipelineInfo != nil {
		l = m.PipelineInfo.Size()
		n += 1 + l + sovDevices(uint64(l))
	}
	if m.Pos != nil {
		l = m.Pos.Size()
		n += 1 + l + sovDevices(uint64(l))
	}
	if len(m.Connections) > 0 {
		for _, e := range m.Connections {
			l = e.Size()
			n += 1 + l + sovDevices(uint64(l))
		}
	}
	if m.TotalConnections != 0 {
		n += 1 + sovDevices(uint64(m.TotalConnections))
	}
	if m.IOStats != nil {
		l = m.IOStats.Size()
		n += 1 + l + sovDevices(uint64(l))
	}
	return n
}

func (m *Port) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ID)
	if l > 0 {
		n += 1 + l + sovDevices(uint64(l))
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovDevices(uint64(l))
	}
	if m.Number != 0 {
		n += 1 + sovDevices(uint64(m.Number))
	}
	if m.InternalNumber != 0 {
		n += 1 + sovDevices(uint64(m.InternalNumber))
	}
	l = len(m.Speed)
	if l > 0 {
		n += 1 + l + sovDevices(uint64(l))
	}
	if m.Enabled {
		n += 2
	}
	return n
}

func (m *PipelineInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Cookie != 0 {
		n += 1 + sovDevices(uint64(m.Cookie))
	}
	l = len(m.P4Info)
	if l > 0 {
		n += 1 + l + sovDevices(uint64(l))
	}
	if len(m.Tables) > 0 {
		for _, e := range m.Tables {
			l = e.Size()
			n += 1 + l + sovDevices(uint64(l))
		}
	}
	if len(m.Counters) > 0 {
		for _, e := range m.Counters {
			l = e.Size()
			n += 1 + l + sovDevices(uint64(l))
		}
	}
	if len(m.Meters) > 0 {
		for _, e := range m.Meters {
			l = e.Size()
			n += 1 + l + sovDevices(uint64(l))
		}
	}
	if len(m.Groups) > 0 {
		for _, e := range m.Groups {
			l = e.Size()
			n += 1 + l + sovDevices(uint64(l))
		}
	}
	if len(m.MulticastGroups) > 0 {
		for _, e := range m.MulticastGroups {
			l = e.Size()
			n += 1 + l + sovDevices(uint64(l))
		}
	}
	if len(m.CloneSessions) > 0 {
		for _, e := range m.CloneSessions {
			l = e.Size()
			n += 1 + l + sovDevices(uint64(l))
		}
	}
	return n
}

func (m *EntitiesInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ID != 0 {
		n += 1 + sovDevices(uint64(m.ID))
	}
	if m.Size_ != 0 {
		n += 1 + sovDevices(uint64(m.Size_))
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovDevices(uint64(l))
	}
	return n
}

func (m *GetDevicesRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *GetDevicesResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Devices) > 0 {
		for _, e := range m.Devices {
			l = e.Size()
			n += 1 + l + sovDevices(uint64(l))
		}
	}
	return n
}

func (m *GetDeviceRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ID)
	if l > 0 {
		n += 1 + l + sovDevices(uint64(l))
	}
	return n
}

func (m *GetDeviceResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Device != nil {
		l = m.Device.Size()
		n += 1 + l + sovDevices(uint64(l))
	}
	return n
}

func (m *AddDeviceRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Device != nil {
		l = m.Device.Size()
		n += 1 + l + sovDevices(uint64(l))
	}
	return n
}

func (m *AddDeviceResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RemoveDeviceRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ID)
	if l > 0 {
		n += 1 + l + sovDevices(uint64(l))
	}
	return n
}

func (m *RemoveDeviceResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *StopDeviceRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ID)
	if l > 0 {
		n += 1 + l + sovDevices(uint64(l))
	}
	if m.Mode != 0 {
		n += 1 + sovDevices(uint64(m.Mode))
	}
	return n
}

func (m *StopDeviceResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *StartDeviceRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ID)
	if l > 0 {
		n += 1 + l + sovDevices(uint64(l))
	}
	return n
}

func (m *StartDeviceResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *DisablePortRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ID)
	if l > 0 {
		n += 1 + l + sovDevices(uint64(l))
	}
	if m.Mode != 0 {
		n += 1 + sovDevices(uint64(m.Mode))
	}
	return n
}

func (m *DisablePortResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *EnablePortRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ID)
	if l > 0 {
		n += 1 + l + sovDevices(uint64(l))
	}
	return n
}

func (m *EnablePortResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *EmitLLDPPacketRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.PortID)
	if l > 0 {
		n += 1 + l + sovDevices(uint64(l))
	}
	l = len(m.Packet)
	if l > 0 {
		n += 1 + l + sovDevices(uint64(l))
	}
	return n
}

func (m *EmitLLDPPacketResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func sovDevices(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozDevices(x uint64) (n int) {
	return sovDevices(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *Device) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowDevices
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Device: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Device: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDevices
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthDevices
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDevices
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ID = DeviceID(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			m.Type = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDevices
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= DeviceType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Ports", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDevices
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDevices
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDevices
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Ports = append(m.Ports, &Port{})
			if err := m.Ports[len(m.Ports)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ControlPort", wireType)
			}
			m.ControlPort = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDevices
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ControlPort |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChassisID", wireType)
			}
			m.ChassisID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDevices
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ChassisID |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PipelineInfo", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDevices
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDevices
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDevices
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.PipelineInfo == nil {
				m.PipelineInfo = &PipelineInfo{}
			}
			if err := m.PipelineInfo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Pos", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDevices
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDevices
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDevices
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Pos == nil {
				m.Pos = &misc.GridPosition{}
			}
			if err := m.Pos.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Connections", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDevices
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDevices
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDevices
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Connections = append(m.Connections, &misc.Connection{})
			if err := m.Connections[len(m.Connections)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 9:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TotalConnections", wireType)
			}
			m.TotalConnections = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDevices
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TotalConnections |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field IOStats", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDevices
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDevices
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDevices
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.IOStats == nil {
				m.IOStats = &misc.IOStats{}
			}
			if err := m.IOStats.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDevices(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthDevices
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Port) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowDevices
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Port: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Port: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDevices
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthDevices
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDevices
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ID = PortID(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDevices
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthDevices
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDevices
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Number", wireType)
			}
			m.Number = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDevices
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Number |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field InternalNumber", wireType)
			}
			m.InternalNumber = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDevices
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.InternalNumber |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Speed", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDevices
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthDevices
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDevices
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Speed = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Enabled", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDevices
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Enabled = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipDevices(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthDevices
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *PipelineInfo) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowDevices
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: PipelineInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PipelineInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Cookie", wireType)
			}
			m.Cookie = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDevices
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Cookie |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field P4Info", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDevices
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthDevices
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthDevices
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.P4Info = append(m.P4Info[:0], dAtA[iNdEx:postIndex]...)
			if m.P4Info == nil {
				m.P4Info = []byte{}
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Tables", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDevices
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDevices
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDevices
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Tables = append(m.Tables, &EntitiesInfo{})
			if err := m.Tables[len(m.Tables)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Counters", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDevices
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDevices
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDevices
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Counters = append(m.Counters, &EntitiesInfo{})
			if err := m.Counters[len(m.Counters)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Meters", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDevices
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDevices
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDevices
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Meters = append(m.Meters, &EntitiesInfo{})
			if err := m.Meters[len(m.Meters)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Groups", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDevices
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDevices
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDevices
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Groups = append(m.Groups, &EntitiesInfo{})
			if err := m.Groups[len(m.Groups)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MulticastGroups", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDevices
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDevices
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDevices
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.MulticastGroups = append(m.MulticastGroups, &EntitiesInfo{})
			if err := m.MulticastGroups[len(m.MulticastGroups)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CloneSessions", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDevices
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDevices
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDevices
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.CloneSessions = append(m.CloneSessions, &EntitiesInfo{})
			if err := m.CloneSessions[len(m.CloneSessions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDevices(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthDevices
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EntitiesInfo) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowDevices
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: EntitiesInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EntitiesInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
			}
			m.ID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDevices
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ID |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Size_", wireType)
			}
			m.Size_ = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDevices
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Size_ |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDevices
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthDevices
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDevices
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDevices(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthDevices
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GetDevicesRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowDevices
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: GetDevicesRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetDevicesRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipDevices(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthDevices
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GetDevicesResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowDevices
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: GetDevicesResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetDevicesResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Devices", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDevices
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDevices
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDevices
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Devices = append(m.Devices, &Device{})
			if err := m.Devices[len(m.Devices)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDevices(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthDevices
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GetDeviceRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowDevices
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: GetDeviceRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetDeviceRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDevices
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthDevices
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDevices
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ID = DeviceID(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDevices(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthDevices
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GetDeviceResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowDevices
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: GetDeviceResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetDeviceResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Device", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDevices
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDevices
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDevices
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Device == nil {
				m.Device = &Device{}
			}
			if err := m.Device.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDevices(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthDevices
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AddDeviceRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowDevices
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: AddDeviceRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AddDeviceRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Device", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDevices
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDevices
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDevices
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Device == nil {
				m.Device = &Device{}
			}
			if err := m.Device.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDevices(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthDevices
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AddDeviceResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowDevices
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: AddDeviceResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AddDeviceResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipDevices(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthDevices
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RemoveDeviceRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowDevices
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: RemoveDeviceRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RemoveDeviceRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDevices
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthDevices
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDevices
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ID = DeviceID(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDevices(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthDevices
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RemoveDeviceResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowDevices
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: RemoveDeviceResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RemoveDeviceResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipDevices(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthDevices
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *StopDeviceRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowDevices
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: StopDeviceRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: StopDeviceRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDevices
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthDevices
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDevices
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ID = DeviceID(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Mode", wireType)
			}
			m.Mode = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDevices
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Mode |= StopMode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipDevices(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthDevices
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *StopDeviceResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowDevices
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: StopDeviceResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: StopDeviceResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipDevices(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthDevices
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *StartDeviceRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowDevices
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: StartDeviceRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: StartDeviceRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDevices
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthDevices
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDevices
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ID = DeviceID(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDevices(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthDevices
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *StartDeviceResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowDevices
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: StartDeviceResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: StartDeviceResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipDevices(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthDevices
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DisablePortRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowDevices
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: DisablePortRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DisablePortRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDevices
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthDevices
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDevices
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ID = PortID(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Mode", wireType)
			}
			m.Mode = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDevices
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Mode |= StopMode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipDevices(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthDevices
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DisablePortResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowDevices
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: DisablePortResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DisablePortResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipDevices(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthDevices
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EnablePortRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowDevices
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: EnablePortRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EnablePortRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDevices
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthDevices
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDevices
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ID = PortID(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDevices(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthDevices
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EnablePortResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowDevices
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: EnablePortResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EnablePortResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipDevices(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthDevices
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EmitLLDPPacketRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowDevices
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: EmitLLDPPacketRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EmitLLDPPacketRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PortID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDevices
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthDevices
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDevices
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PortID = PortID(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Packet", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDevices
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthDevices
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthDevices
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Packet = append(m.Packet[:0], dAtA[iNdEx:postIndex]...)
			if m.Packet == nil {
				m.Packet = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDevices(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthDevices
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EmitLLDPPacketResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowDevices
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: EmitLLDPPacketResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EmitLLDPPacketResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipDevices(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthDevices
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipDevices(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	depth := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowDevices
			}
			if iNdEx >= l {
				return 0, io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		wireType := int(wire & 0x7)
		switch wireType {
		case 0:
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowDevices
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
		case 1:
			iNdEx += 8
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowDevices
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if length < 0 {
				return 0, ErrInvalidLengthDevices
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupDevices
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthDevices
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthDevices        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowDevices          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupDevices = fmt.Errorf("proto: unexpected end of group")
)