github.com/onosproject/onos-api/go@v0.10.32/onos/ransim/trafficsim/trafficsim.pb.go

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

package trafficsim

import (
	context "context"
	fmt "fmt"
	proto "github.com/gogo/protobuf/proto"
	types "github.com/onosproject/onos-api/go/onos/ransim/types"
	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

// Change event type
type Type int32

const (
	// NONE indicates this response does not represent a modification of the Change
	Type_NONE Type = 0
	// ADDED is an event which occurs when a Change is added to the topology
	Type_ADDED Type = 1
	// UPDATED is an event which occurs when a Change is updated
	Type_UPDATED Type = 2
	// REMOVED is an event which occurs when a Change is removed from the configuration
	Type_REMOVED Type = 3
)

var Type_name = map[int32]string{
	0: "NONE",
	1: "ADDED",
	2: "UPDATED",
	3: "REMOVED",
}

var Type_value = map[string]int32{
	"NONE":    0,
	"ADDED":   1,
	"UPDATED": 2,
	"REMOVED": 3,
}

func (x Type) String() string {
	return proto.EnumName(Type_name, int32(x))
}

func (Type) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_9ed0b8d1f9f6964b, []int{0}
}

// In the case of an update this helps qualify the update type - add items as necessary
type UpdateType int32

const (
	UpdateType_NOUPDATETYPE UpdateType = 0
	// POSITION An update in position of UE only, without a change in the Tower affinity
	UpdateType_POSITION UpdateType = 1
	// TOWER An update in non-serving tower affinity (and also position) of UE
	UpdateType_TOWER UpdateType = 2
	// HANDOVER An update of the serving tower
	UpdateType_HANDOVER UpdateType = 3
)

var UpdateType_name = map[int32]string{
	0: "NOUPDATETYPE",
	1: "POSITION",
	2: "TOWER",
	3: "HANDOVER",
}

var UpdateType_value = map[string]int32{
	"NOUPDATETYPE": 0,
	"POSITION":     1,
	"TOWER":        2,
	"HANDOVER":     3,
}

func (x UpdateType) String() string {
	return proto.EnumName(UpdateType_name, int32(x))
}

func (UpdateType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_9ed0b8d1f9f6964b, []int{1}
}

type MapLayoutRequest struct {
}

func (m *MapLayoutRequest) Reset()         { *m = MapLayoutRequest{} }
func (m *MapLayoutRequest) String() string { return proto.CompactTextString(m) }
func (*MapLayoutRequest) ProtoMessage()    {}
func (*MapLayoutRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_9ed0b8d1f9f6964b, []int{0}
}
func (m *MapLayoutRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MapLayoutRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MapLayoutRequest.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 *MapLayoutRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MapLayoutRequest.Merge(m, src)
}
func (m *MapLayoutRequest) XXX_Size() int {
	return m.Size()
}
func (m *MapLayoutRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_MapLayoutRequest.DiscardUnknown(m)
}

var xxx_messageInfo_MapLayoutRequest proto.InternalMessageInfo

type ListRoutesRequest struct {
	NoReplay    bool `protobuf:"varint,1,opt,name=no_replay,json=noReplay,proto3" json:"no_replay,omitempty"`
	NoSubscribe bool `protobuf:"varint,2,opt,name=no_subscribe,json=noSubscribe,proto3" json:"no_subscribe,omitempty"`
}

func (m *ListRoutesRequest) Reset()         { *m = ListRoutesRequest{} }
func (m *ListRoutesRequest) String() string { return proto.CompactTextString(m) }
func (*ListRoutesRequest) ProtoMessage()    {}
func (*ListRoutesRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_9ed0b8d1f9f6964b, []int{1}
}
func (m *ListRoutesRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ListRoutesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ListRoutesRequest.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 *ListRoutesRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ListRoutesRequest.Merge(m, src)
}
func (m *ListRoutesRequest) XXX_Size() int {
	return m.Size()
}
func (m *ListRoutesRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_ListRoutesRequest.DiscardUnknown(m)
}

var xxx_messageInfo_ListRoutesRequest proto.InternalMessageInfo

func (m *ListRoutesRequest) GetNoReplay() bool {
	if m != nil {
		return m.NoReplay
	}
	return false
}

func (m *ListRoutesRequest) GetNoSubscribe() bool {
	if m != nil {
		return m.NoSubscribe
	}
	return false
}

type ListRoutesResponse struct {
	// route is the route change on which the event occurred
	Route *types.Route `protobuf:"bytes,1,opt,name=route,proto3" json:"route,omitempty"`
	// type is a qualification of the type of change being made
	Type Type `protobuf:"varint,2,opt,name=type,proto3,enum=onos.ransim.trafficsim.Type" json:"type,omitempty"`
}

func (m *ListRoutesResponse) Reset()         { *m = ListRoutesResponse{} }
func (m *ListRoutesResponse) String() string { return proto.CompactTextString(m) }
func (*ListRoutesResponse) ProtoMessage()    {}
func (*ListRoutesResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_9ed0b8d1f9f6964b, []int{2}
}
func (m *ListRoutesResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ListRoutesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ListRoutesResponse.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 *ListRoutesResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ListRoutesResponse.Merge(m, src)
}
func (m *ListRoutesResponse) XXX_Size() int {
	return m.Size()
}
func (m *ListRoutesResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_ListRoutesResponse.DiscardUnknown(m)
}

var xxx_messageInfo_ListRoutesResponse proto.InternalMessageInfo

func (m *ListRoutesResponse) GetRoute() *types.Route {
	if m != nil {
		return m.Route
	}
	return nil
}

func (m *ListRoutesResponse) GetType() Type {
	if m != nil {
		return m.Type
	}
	return Type_NONE
}

type ListUesRequest struct {
}

func (m *ListUesRequest) Reset()         { *m = ListUesRequest{} }
func (m *ListUesRequest) String() string { return proto.CompactTextString(m) }
func (*ListUesRequest) ProtoMessage()    {}
func (*ListUesRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_9ed0b8d1f9f6964b, []int{3}
}
func (m *ListUesRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ListUesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ListUesRequest.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 *ListUesRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ListUesRequest.Merge(m, src)
}
func (m *ListUesRequest) XXX_Size() int {
	return m.Size()
}
func (m *ListUesRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_ListUesRequest.DiscardUnknown(m)
}

var xxx_messageInfo_ListUesRequest proto.InternalMessageInfo

type ListUesResponse struct {
	// Ue is the UserEquipment change on which the event occurred
	Ue *types.Ue `protobuf:"bytes,1,opt,name=ue,proto3" json:"ue,omitempty"`
}

func (m *ListUesResponse) Reset()         { *m = ListUesResponse{} }
func (m *ListUesResponse) String() string { return proto.CompactTextString(m) }
func (*ListUesResponse) ProtoMessage()    {}
func (*ListUesResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_9ed0b8d1f9f6964b, []int{4}
}
func (m *ListUesResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ListUesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ListUesResponse.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 *ListUesResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ListUesResponse.Merge(m, src)
}
func (m *ListUesResponse) XXX_Size() int {
	return m.Size()
}
func (m *ListUesResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_ListUesResponse.DiscardUnknown(m)
}

var xxx_messageInfo_ListUesResponse proto.InternalMessageInfo

func (m *ListUesResponse) GetUe() *types.Ue {
	if m != nil {
		return m.Ue
	}
	return nil
}

type WatchUesRequest struct {
	NoReplay    bool `protobuf:"varint,1,opt,name=no_replay,json=noReplay,proto3" json:"no_replay,omitempty"`
	NoSubscribe bool `protobuf:"varint,2,opt,name=no_subscribe,json=noSubscribe,proto3" json:"no_subscribe,omitempty"`
}

func (m *WatchUesRequest) Reset()         { *m = WatchUesRequest{} }
func (m *WatchUesRequest) String() string { return proto.CompactTextString(m) }
func (*WatchUesRequest) ProtoMessage()    {}
func (*WatchUesRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_9ed0b8d1f9f6964b, []int{5}
}
func (m *WatchUesRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *WatchUesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_WatchUesRequest.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 *WatchUesRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_WatchUesRequest.Merge(m, src)
}
func (m *WatchUesRequest) XXX_Size() int {
	return m.Size()
}
func (m *WatchUesRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_WatchUesRequest.DiscardUnknown(m)
}

var xxx_messageInfo_WatchUesRequest proto.InternalMessageInfo

func (m *WatchUesRequest) GetNoReplay() bool {
	if m != nil {
		return m.NoReplay
	}
	return false
}

func (m *WatchUesRequest) GetNoSubscribe() bool {
	if m != nil {
		return m.NoSubscribe
	}
	return false
}

type WatchUesResponse struct {
	// Ue is the UserEquipment change on which the event occurred
	Ue *types.Ue `protobuf:"bytes,1,opt,name=ue,proto3" json:"ue,omitempty"`
	// type is a qualification of the type of change being made
	Type Type `protobuf:"varint,2,opt,name=type,proto3,enum=onos.ransim.trafficsim.Type" json:"type,omitempty"`
	// update_type is a qualification of the type of UE change
	UpdateType UpdateType `protobuf:"varint,3,opt,name=update_type,json=updateType,proto3,enum=onos.ransim.trafficsim.UpdateType" json:"update_type,omitempty"`
}

func (m *WatchUesResponse) Reset()         { *m = WatchUesResponse{} }
func (m *WatchUesResponse) String() string { return proto.CompactTextString(m) }
func (*WatchUesResponse) ProtoMessage()    {}
func (*WatchUesResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_9ed0b8d1f9f6964b, []int{6}
}
func (m *WatchUesResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *WatchUesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_WatchUesResponse.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 *WatchUesResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_WatchUesResponse.Merge(m, src)
}
func (m *WatchUesResponse) XXX_Size() int {
	return m.Size()
}
func (m *WatchUesResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_WatchUesResponse.DiscardUnknown(m)
}

var xxx_messageInfo_WatchUesResponse proto.InternalMessageInfo

func (m *WatchUesResponse) GetUe() *types.Ue {
	if m != nil {
		return m.Ue
	}
	return nil
}

func (m *WatchUesResponse) GetType() Type {
	if m != nil {
		return m.Type
	}
	return Type_NONE
}

func (m *WatchUesResponse) GetUpdateType() UpdateType {
	if m != nil {
		return m.UpdateType
	}
	return UpdateType_NOUPDATETYPE
}

type SetNumberUEsRequest struct {
	Number uint32 `protobuf:"varint,1,opt,name=number,proto3" json:"number,omitempty"`
}

func (m *SetNumberUEsRequest) Reset()         { *m = SetNumberUEsRequest{} }
func (m *SetNumberUEsRequest) String() string { return proto.CompactTextString(m) }
func (*SetNumberUEsRequest) ProtoMessage()    {}
func (*SetNumberUEsRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_9ed0b8d1f9f6964b, []int{7}
}
func (m *SetNumberUEsRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *SetNumberUEsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_SetNumberUEsRequest.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 *SetNumberUEsRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SetNumberUEsRequest.Merge(m, src)
}
func (m *SetNumberUEsRequest) XXX_Size() int {
	return m.Size()
}
func (m *SetNumberUEsRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_SetNumberUEsRequest.DiscardUnknown(m)
}

var xxx_messageInfo_SetNumberUEsRequest proto.InternalMessageInfo

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

type SetNumberUEsResponse struct {
	Number uint32 `protobuf:"varint,1,opt,name=number,proto3" json:"number,omitempty"`
}

func (m *SetNumberUEsResponse) Reset()         { *m = SetNumberUEsResponse{} }
func (m *SetNumberUEsResponse) String() string { return proto.CompactTextString(m) }
func (*SetNumberUEsResponse) ProtoMessage()    {}
func (*SetNumberUEsResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_9ed0b8d1f9f6964b, []int{8}
}
func (m *SetNumberUEsResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *SetNumberUEsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_SetNumberUEsResponse.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 *SetNumberUEsResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SetNumberUEsResponse.Merge(m, src)
}
func (m *SetNumberUEsResponse) XXX_Size() int {
	return m.Size()
}
func (m *SetNumberUEsResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_SetNumberUEsResponse.DiscardUnknown(m)
}

var xxx_messageInfo_SetNumberUEsResponse proto.InternalMessageInfo

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

type ResetMetricsMsg struct {
}

func (m *ResetMetricsMsg) Reset()         { *m = ResetMetricsMsg{} }
func (m *ResetMetricsMsg) String() string { return proto.CompactTextString(m) }
func (*ResetMetricsMsg) ProtoMessage()    {}
func (*ResetMetricsMsg) Descriptor() ([]byte, []int) {
	return fileDescriptor_9ed0b8d1f9f6964b, []int{9}
}
func (m *ResetMetricsMsg) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ResetMetricsMsg) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ResetMetricsMsg.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 *ResetMetricsMsg) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ResetMetricsMsg.Merge(m, src)
}
func (m *ResetMetricsMsg) XXX_Size() int {
	return m.Size()
}
func (m *ResetMetricsMsg) XXX_DiscardUnknown() {
	xxx_messageInfo_ResetMetricsMsg.DiscardUnknown(m)
}

var xxx_messageInfo_ResetMetricsMsg proto.InternalMessageInfo

func init() {
	proto.RegisterEnum("onos.ransim.trafficsim.Type", Type_name, Type_value)
	proto.RegisterEnum("onos.ransim.trafficsim.UpdateType", UpdateType_name, UpdateType_value)
	proto.RegisterType((*MapLayoutRequest)(nil), "onos.ransim.trafficsim.MapLayoutRequest")
	proto.RegisterType((*ListRoutesRequest)(nil), "onos.ransim.trafficsim.ListRoutesRequest")
	proto.RegisterType((*ListRoutesResponse)(nil), "onos.ransim.trafficsim.ListRoutesResponse")
	proto.RegisterType((*ListUesRequest)(nil), "onos.ransim.trafficsim.ListUesRequest")
	proto.RegisterType((*ListUesResponse)(nil), "onos.ransim.trafficsim.ListUesResponse")
	proto.RegisterType((*WatchUesRequest)(nil), "onos.ransim.trafficsim.WatchUesRequest")
	proto.RegisterType((*WatchUesResponse)(nil), "onos.ransim.trafficsim.WatchUesResponse")
	proto.RegisterType((*SetNumberUEsRequest)(nil), "onos.ransim.trafficsim.SetNumberUEsRequest")
	proto.RegisterType((*SetNumberUEsResponse)(nil), "onos.ransim.trafficsim.SetNumberUEsResponse")
	proto.RegisterType((*ResetMetricsMsg)(nil), "onos.ransim.trafficsim.ResetMetricsMsg")
}

func init() {
	proto.RegisterFile("onos/ransim/trafficsim/trafficsim.proto", fileDescriptor_9ed0b8d1f9f6964b)
}

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

// TrafficClient is the client API for Traffic service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type TrafficClient interface {
	GetMapLayout(ctx context.Context, in *MapLayoutRequest, opts ...grpc.CallOption) (*types.MapLayout, error)
	ListRoutes(ctx context.Context, in *ListRoutesRequest, opts ...grpc.CallOption) (Traffic_ListRoutesClient, error)
	ListUes(ctx context.Context, in *ListUesRequest, opts ...grpc.CallOption) (Traffic_ListUesClient, error)
	WatchUes(ctx context.Context, in *WatchUesRequest, opts ...grpc.CallOption) (Traffic_WatchUesClient, error)
	SetNumberUEs(ctx context.Context, in *SetNumberUEsRequest, opts ...grpc.CallOption) (*SetNumberUEsResponse, error)
	ResetMetrics(ctx context.Context, in *ResetMetricsMsg, opts ...grpc.CallOption) (*ResetMetricsMsg, error)
}

type trafficClient struct {
	cc *grpc.ClientConn
}

func NewTrafficClient(cc *grpc.ClientConn) TrafficClient {
	return &trafficClient{cc}
}

func (c *trafficClient) GetMapLayout(ctx context.Context, in *MapLayoutRequest, opts ...grpc.CallOption) (*types.MapLayout, error) {
	out := new(types.MapLayout)
	err := c.cc.Invoke(ctx, "/onos.ransim.trafficsim.Traffic/GetMapLayout", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *trafficClient) ListRoutes(ctx context.Context, in *ListRoutesRequest, opts ...grpc.CallOption) (Traffic_ListRoutesClient, error) {
	stream, err := c.cc.NewStream(ctx, &_Traffic_serviceDesc.Streams[0], "/onos.ransim.trafficsim.Traffic/ListRoutes", opts...)
	if err != nil {
		return nil, err
	}
	x := &trafficListRoutesClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type Traffic_ListRoutesClient interface {
	Recv() (*ListRoutesResponse, error)
	grpc.ClientStream
}

type trafficListRoutesClient struct {
	grpc.ClientStream
}

func (x *trafficListRoutesClient) Recv() (*ListRoutesResponse, error) {
	m := new(ListRoutesResponse)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *trafficClient) ListUes(ctx context.Context, in *ListUesRequest, opts ...grpc.CallOption) (Traffic_ListUesClient, error) {
	stream, err := c.cc.NewStream(ctx, &_Traffic_serviceDesc.Streams[1], "/onos.ransim.trafficsim.Traffic/ListUes", opts...)
	if err != nil {
		return nil, err
	}
	x := &trafficListUesClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type Traffic_ListUesClient interface {
	Recv() (*ListUesResponse, error)
	grpc.ClientStream
}

type trafficListUesClient struct {
	grpc.ClientStream
}

func (x *trafficListUesClient) Recv() (*ListUesResponse, error) {
	m := new(ListUesResponse)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *trafficClient) WatchUes(ctx context.Context, in *WatchUesRequest, opts ...grpc.CallOption) (Traffic_WatchUesClient, error) {
	stream, err := c.cc.NewStream(ctx, &_Traffic_serviceDesc.Streams[2], "/onos.ransim.trafficsim.Traffic/WatchUes", opts...)
	if err != nil {
		return nil, err
	}
	x := &trafficWatchUesClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type Traffic_WatchUesClient interface {
	Recv() (*WatchUesResponse, error)
	grpc.ClientStream
}

type trafficWatchUesClient struct {
	grpc.ClientStream
}

func (x *trafficWatchUesClient) Recv() (*WatchUesResponse, error) {
	m := new(WatchUesResponse)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *trafficClient) SetNumberUEs(ctx context.Context, in *SetNumberUEsRequest, opts ...grpc.CallOption) (*SetNumberUEsResponse, error) {
	out := new(SetNumberUEsResponse)
	err := c.cc.Invoke(ctx, "/onos.ransim.trafficsim.Traffic/SetNumberUEs", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *trafficClient) ResetMetrics(ctx context.Context, in *ResetMetricsMsg, opts ...grpc.CallOption) (*ResetMetricsMsg, error) {
	out := new(ResetMetricsMsg)
	err := c.cc.Invoke(ctx, "/onos.ransim.trafficsim.Traffic/ResetMetrics", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// TrafficServer is the server API for Traffic service.
type TrafficServer interface {
	GetMapLayout(context.Context, *MapLayoutRequest) (*types.MapLayout, error)
	ListRoutes(*ListRoutesRequest, Traffic_ListRoutesServer) error
	ListUes(*ListUesRequest, Traffic_ListUesServer) error
	WatchUes(*WatchUesRequest, Traffic_WatchUesServer) error
	SetNumberUEs(context.Context, *SetNumberUEsRequest) (*SetNumberUEsResponse, error)
	ResetMetrics(context.Context, *ResetMetricsMsg) (*ResetMetricsMsg, error)
}

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

func (*UnimplementedTrafficServer) GetMapLayout(ctx context.Context, req *MapLayoutRequest) (*types.MapLayout, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetMapLayout not implemented")
}
func (*UnimplementedTrafficServer) ListRoutes(req *ListRoutesRequest, srv Traffic_ListRoutesServer) error {
	return status.Errorf(codes.Unimplemented, "method ListRoutes not implemented")
}
func (*UnimplementedTrafficServer) ListUes(req *ListUesRequest, srv Traffic_ListUesServer) error {
	return status.Errorf(codes.Unimplemented, "method ListUes not implemented")
}
func (*UnimplementedTrafficServer) WatchUes(req *WatchUesRequest, srv Traffic_WatchUesServer) error {
	return status.Errorf(codes.Unimplemented, "method WatchUes not implemented")
}
func (*UnimplementedTrafficServer) SetNumberUEs(ctx context.Context, req *SetNumberUEsRequest) (*SetNumberUEsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SetNumberUEs not implemented")
}
func (*UnimplementedTrafficServer) ResetMetrics(ctx context.Context, req *ResetMetricsMsg) (*ResetMetricsMsg, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ResetMetrics not implemented")
}

func RegisterTrafficServer(s *grpc.Server, srv TrafficServer) {
	s.RegisterService(&_Traffic_serviceDesc, srv)
}

func _Traffic_GetMapLayout_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MapLayoutRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TrafficServer).GetMapLayout(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/onos.ransim.trafficsim.Traffic/GetMapLayout",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TrafficServer).GetMapLayout(ctx, req.(*MapLayoutRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Traffic_ListRoutes_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(ListRoutesRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(TrafficServer).ListRoutes(m, &trafficListRoutesServer{stream})
}

type Traffic_ListRoutesServer interface {
	Send(*ListRoutesResponse) error
	grpc.ServerStream
}

type trafficListRoutesServer struct {
	grpc.ServerStream
}

func (x *trafficListRoutesServer) Send(m *ListRoutesResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _Traffic_ListUes_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(ListUesRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(TrafficServer).ListUes(m, &trafficListUesServer{stream})
}

type Traffic_ListUesServer interface {
	Send(*ListUesResponse) error
	grpc.ServerStream
}

type trafficListUesServer struct {
	grpc.ServerStream
}

func (x *trafficListUesServer) Send(m *ListUesResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _Traffic_WatchUes_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(WatchUesRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(TrafficServer).WatchUes(m, &trafficWatchUesServer{stream})
}

type Traffic_WatchUesServer interface {
	Send(*WatchUesResponse) error
	grpc.ServerStream
}

type trafficWatchUesServer struct {
	grpc.ServerStream
}

func (x *trafficWatchUesServer) Send(m *WatchUesResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _Traffic_SetNumberUEs_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SetNumberUEsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TrafficServer).SetNumberUEs(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/onos.ransim.trafficsim.Traffic/SetNumberUEs",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TrafficServer).SetNumberUEs(ctx, req.(*SetNumberUEsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Traffic_ResetMetrics_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ResetMetricsMsg)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TrafficServer).ResetMetrics(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/onos.ransim.trafficsim.Traffic/ResetMetrics",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TrafficServer).ResetMetrics(ctx, req.(*ResetMetricsMsg))
	}
	return interceptor(ctx, in, info, handler)
}

var _Traffic_serviceDesc = grpc.ServiceDesc{
	ServiceName: "onos.ransim.trafficsim.Traffic",
	HandlerType: (*TrafficServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetMapLayout",
			Handler:    _Traffic_GetMapLayout_Handler,
		},
		{
			MethodName: "SetNumberUEs",
			Handler:    _Traffic_SetNumberUEs_Handler,
		},
		{
			MethodName: "ResetMetrics",
			Handler:    _Traffic_ResetMetrics_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "ListRoutes",
			Handler:       _Traffic_ListRoutes_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "ListUes",
			Handler:       _Traffic_ListUes_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "WatchUes",
			Handler:       _Traffic_WatchUes_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "onos/ransim/trafficsim/trafficsim.proto",
}

func (m *MapLayoutRequest) 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 *MapLayoutRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *ListRoutesRequest) 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 *ListRoutesRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ListRoutesRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.NoSubscribe {
		i--
		if m.NoSubscribe {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x10
	}
	if m.NoReplay {
		i--
		if m.NoReplay {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *ListRoutesResponse) 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 *ListRoutesResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *ListUesRequest) 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 *ListUesRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *ListUesResponse) 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 *ListUesResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *WatchUesRequest) 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 *WatchUesRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *WatchUesRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.NoSubscribe {
		i--
		if m.NoSubscribe {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x10
	}
	if m.NoReplay {
		i--
		if m.NoReplay {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *WatchUesResponse) 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 *WatchUesResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *WatchUesResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.UpdateType != 0 {
		i = encodeVarintTrafficsim(dAtA, i, uint64(m.UpdateType))
		i--
		dAtA[i] = 0x18
	}
	if m.Type != 0 {
		i = encodeVarintTrafficsim(dAtA, i, uint64(m.Type))
		i--
		dAtA[i] = 0x10
	}
	if m.Ue != nil {
		{
			size, err := m.Ue.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTrafficsim(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *SetNumberUEsRequest) 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 *SetNumberUEsRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *SetNumberUEsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Number != 0 {
		i = encodeVarintTrafficsim(dAtA, i, uint64(m.Number))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *SetNumberUEsResponse) 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 *SetNumberUEsResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *SetNumberUEsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Number != 0 {
		i = encodeVarintTrafficsim(dAtA, i, uint64(m.Number))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *ResetMetricsMsg) 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 *ResetMetricsMsg) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func encodeVarintTrafficsim(dAtA []byte, offset int, v uint64) int {
	offset -= sovTrafficsim(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *MapLayoutRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *ListRoutesRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.NoReplay {
		n += 2
	}
	if m.NoSubscribe {
		n += 2
	}
	return n
}

func (m *ListRoutesResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Route != nil {
		l = m.Route.Size()
		n += 1 + l + sovTrafficsim(uint64(l))
	}
	if m.Type != 0 {
		n += 1 + sovTrafficsim(uint64(m.Type))
	}
	return n
}

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

func (m *ListUesResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Ue != nil {
		l = m.Ue.Size()
		n += 1 + l + sovTrafficsim(uint64(l))
	}
	return n
}

func (m *WatchUesRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.NoReplay {
		n += 2
	}
	if m.NoSubscribe {
		n += 2
	}
	return n
}

func (m *WatchUesResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Ue != nil {
		l = m.Ue.Size()
		n += 1 + l + sovTrafficsim(uint64(l))
	}
	if m.Type != 0 {
		n += 1 + sovTrafficsim(uint64(m.Type))
	}
	if m.UpdateType != 0 {
		n += 1 + sovTrafficsim(uint64(m.UpdateType))
	}
	return n
}

func (m *SetNumberUEsRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Number != 0 {
		n += 1 + sovTrafficsim(uint64(m.Number))
	}
	return n
}

func (m *SetNumberUEsResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Number != 0 {
		n += 1 + sovTrafficsim(uint64(m.Number))
	}
	return n
}

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

func sovTrafficsim(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozTrafficsim(x uint64) (n int) {
	return sovTrafficsim(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *MapLayoutRequest) 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 ErrIntOverflowTrafficsim
			}
			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: MapLayoutRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MapLayoutRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipTrafficsim(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTrafficsim
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ListRoutesRequest) 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 ErrIntOverflowTrafficsim
			}
			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: ListRoutesRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ListRoutesRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NoReplay", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTrafficsim
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.NoReplay = bool(v != 0)
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NoSubscribe", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTrafficsim
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.NoSubscribe = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipTrafficsim(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTrafficsim
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ListRoutesResponse) 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 ErrIntOverflowTrafficsim
			}
			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: ListRoutesResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ListRoutesResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Route", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTrafficsim
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTrafficsim
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTrafficsim
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Route == nil {
				m.Route = &types.Route{}
			}
			if err := m.Route.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			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 ErrIntOverflowTrafficsim
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= Type(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipTrafficsim(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTrafficsim
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ListUesRequest) 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 ErrIntOverflowTrafficsim
			}
			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: ListUesRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ListUesRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipTrafficsim(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTrafficsim
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ListUesResponse) 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 ErrIntOverflowTrafficsim
			}
			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: ListUesResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ListUesResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Ue", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTrafficsim
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTrafficsim
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTrafficsim
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Ue == nil {
				m.Ue = &types.Ue{}
			}
			if err := m.Ue.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTrafficsim(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTrafficsim
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *WatchUesRequest) 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 ErrIntOverflowTrafficsim
			}
			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: WatchUesRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: WatchUesRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NoReplay", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTrafficsim
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.NoReplay = bool(v != 0)
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NoSubscribe", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTrafficsim
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.NoSubscribe = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipTrafficsim(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTrafficsim
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *WatchUesResponse) 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 ErrIntOverflowTrafficsim
			}
			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: WatchUesResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: WatchUesResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Ue", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTrafficsim
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTrafficsim
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTrafficsim
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Ue == nil {
				m.Ue = &types.Ue{}
			}
			if err := m.Ue.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			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 ErrIntOverflowTrafficsim
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= Type(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field UpdateType", wireType)
			}
			m.UpdateType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTrafficsim
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.UpdateType |= UpdateType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipTrafficsim(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTrafficsim
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SetNumberUEsRequest) 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 ErrIntOverflowTrafficsim
			}
			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: SetNumberUEsRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SetNumberUEsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			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 ErrIntOverflowTrafficsim
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Number |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipTrafficsim(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTrafficsim
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SetNumberUEsResponse) 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 ErrIntOverflowTrafficsim
			}
			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: SetNumberUEsResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SetNumberUEsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			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 ErrIntOverflowTrafficsim
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Number |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipTrafficsim(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTrafficsim
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ResetMetricsMsg) 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 ErrIntOverflowTrafficsim
			}
			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: ResetMetricsMsg: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ResetMetricsMsg: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipTrafficsim(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTrafficsim
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipTrafficsim(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, ErrIntOverflowTrafficsim
			}
			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, ErrIntOverflowTrafficsim
				}
				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, ErrIntOverflowTrafficsim
				}
				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, ErrInvalidLengthTrafficsim
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupTrafficsim
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthTrafficsim
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthTrafficsim        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowTrafficsim          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupTrafficsim = fmt.Errorf("proto: unexpected end of group")
)