application.pb.go

// Code generated by protoc-gen-gogo.
// source: application.proto
// DO NOT EDIT!

/*
	Package core is a generated protocol buffer package.

	It is generated from these files:
		application.proto
		broker.proto
		broker_manager.proto
		collector.proto
		core.proto
		handler.proto
		handler_manager.proto
		lorawan.proto
		router.proto

	It has these top-level messages:
		DataAppReq
		DataAppRes
		JoinAppReq
		JoinAppRes
		DataBrokerReq
		DataBrokerRes
		JoinBrokerReq
		JoinBrokerRes
		ValidateOTAABrokerReq
		ValidateOTAABrokerRes
		UpsertABPBrokerReq
		UpsertABPBrokerRes
		BrokerDevice
		ValidateTokenBrokerReq
		ValidateTokenBrokerRes
		GetApplicationsCollectorReq
		GetApplicationsCollectorRes
		CollectorApplication
		AddApplicationCollectorReq
		AddApplicationCollectorRes
		RemoveApplicationCollectorReq
		RemoveApplicationCollectorRes
		Metadata
		StatsMetadata
		DataUpHandlerReq
		DataUpHandlerRes
		DataDownHandlerReq
		DataDownHandlerRes
		JoinHandlerReq
		JoinHandlerRes
		UpsertOTAAHandlerReq
		UpsertOTAAHandlerRes
		UpsertABPHandlerReq
		UpsertABPHandlerRes
		ListDevicesHandlerReq
		ListDevicesHandlerRes
		HandlerABPDevice
		HandlerOTAADevice
		GetDefaultDeviceReq
		GetDefaultDeviceRes
		SetDefaultDeviceReq
		GetPayloadFunctionsReq
		GetPayloadFunctionsRes
		SetPayloadFunctionsReq
		SetPayloadFunctionsRes
		TestPayloadFunctionsReq
		TestPayloadFunctionsRes
		SetDefaultDeviceRes
		LoRaWANData
		LoRaWANMHDR
		LoRaWANMACPayload
		LoRaWANFHDR
		LoRaWANFCtrl
		LoRaWANJoinRequest
		LoRaWANJoinAccept
		LoRaWANDLSettings
		DataRouterReq
		DataRouterRes
		StatsReq
		StatsRes
		JoinRouterReq
		JoinRouterRes
*/
package core

import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"

import (
	context "golang.org/x/net/context"
	grpc "google.golang.org/grpc"
)

import io "io"

// 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.
const _ = proto.ProtoPackageIsVersion1

type DataAppReq struct {
	AppEUI   []byte      `protobuf:"bytes,1,opt,name=AppEUI,json=appEUI,proto3" json:"AppEUI,omitempty"`
	DevEUI   []byte      `protobuf:"bytes,2,opt,name=DevEUI,json=devEUI,proto3" json:"DevEUI,omitempty"`
	FPort    uint32      `protobuf:"varint,10,opt,name=FPort,json=fPort,proto3" json:"FPort,omitempty"`
	FCnt     uint32      `protobuf:"varint,11,opt,name=FCnt,json=fCnt,proto3" json:"FCnt,omitempty"`
	Payload  []byte      `protobuf:"bytes,20,opt,name=Payload,json=payload,proto3" json:"Payload,omitempty"`
	Metadata []*Metadata `protobuf:"bytes,30,rep,name=Metadata,json=metadata" json:"Metadata,omitempty"`
}

func (m *DataAppReq) Reset()                    { *m = DataAppReq{} }
func (m *DataAppReq) String() string            { return proto.CompactTextString(m) }
func (*DataAppReq) ProtoMessage()               {}
func (*DataAppReq) Descriptor() ([]byte, []int) { return fileDescriptorApplication, []int{0} }

func (m *DataAppReq) GetMetadata() []*Metadata {
	if m != nil {
		return m.Metadata
	}
	return nil
}

type DataAppRes struct {
}

func (m *DataAppRes) Reset()                    { *m = DataAppRes{} }
func (m *DataAppRes) String() string            { return proto.CompactTextString(m) }
func (*DataAppRes) ProtoMessage()               {}
func (*DataAppRes) Descriptor() ([]byte, []int) { return fileDescriptorApplication, []int{1} }

type JoinAppReq struct {
	AppEUI   []byte      `protobuf:"bytes,1,opt,name=AppEUI,json=appEUI,proto3" json:"AppEUI,omitempty"`
	DevEUI   []byte      `protobuf:"bytes,2,opt,name=DevEUI,json=devEUI,proto3" json:"DevEUI,omitempty"`
	Metadata []*Metadata `protobuf:"bytes,30,rep,name=Metadata,json=metadata" json:"Metadata,omitempty"`
}

func (m *JoinAppReq) Reset()                    { *m = JoinAppReq{} }
func (m *JoinAppReq) String() string            { return proto.CompactTextString(m) }
func (*JoinAppReq) ProtoMessage()               {}
func (*JoinAppReq) Descriptor() ([]byte, []int) { return fileDescriptorApplication, []int{2} }

func (m *JoinAppReq) GetMetadata() []*Metadata {
	if m != nil {
		return m.Metadata
	}
	return nil
}

type JoinAppRes struct {
}

func (m *JoinAppRes) Reset()                    { *m = JoinAppRes{} }
func (m *JoinAppRes) String() string            { return proto.CompactTextString(m) }
func (*JoinAppRes) ProtoMessage()               {}
func (*JoinAppRes) Descriptor() ([]byte, []int) { return fileDescriptorApplication, []int{3} }

func init() {
	proto.RegisterType((*DataAppReq)(nil), "core.DataAppReq")
	proto.RegisterType((*DataAppRes)(nil), "core.DataAppRes")
	proto.RegisterType((*JoinAppReq)(nil), "core.JoinAppReq")
	proto.RegisterType((*JoinAppRes)(nil), "core.JoinAppRes")
}

// 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.SupportPackageIsVersion2

// Client API for App service

type AppClient interface {
	HandleData(ctx context.Context, in *DataAppReq, opts ...grpc.CallOption) (*DataAppRes, error)
	HandleJoin(ctx context.Context, in *JoinAppReq, opts ...grpc.CallOption) (*JoinAppRes, error)
}

type appClient struct {
	cc *grpc.ClientConn
}

func NewAppClient(cc *grpc.ClientConn) AppClient {
	return &appClient{cc}
}

func (c *appClient) HandleData(ctx context.Context, in *DataAppReq, opts ...grpc.CallOption) (*DataAppRes, error) {
	out := new(DataAppRes)
	err := grpc.Invoke(ctx, "/core.App/HandleData", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *appClient) HandleJoin(ctx context.Context, in *JoinAppReq, opts ...grpc.CallOption) (*JoinAppRes, error) {
	out := new(JoinAppRes)
	err := grpc.Invoke(ctx, "/core.App/HandleJoin", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// Server API for App service

type AppServer interface {
	HandleData(context.Context, *DataAppReq) (*DataAppRes, error)
	HandleJoin(context.Context, *JoinAppReq) (*JoinAppRes, error)
}

func RegisterAppServer(s *grpc.Server, srv AppServer) {
	s.RegisterService(&_App_serviceDesc, srv)
}

func _App_HandleData_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DataAppReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AppServer).HandleData(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/core.App/HandleData",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AppServer).HandleData(ctx, req.(*DataAppReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _App_HandleJoin_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(JoinAppReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AppServer).HandleJoin(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/core.App/HandleJoin",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AppServer).HandleJoin(ctx, req.(*JoinAppReq))
	}
	return interceptor(ctx, in, info, handler)
}

var _App_serviceDesc = grpc.ServiceDesc{
	ServiceName: "core.App",
	HandlerType: (*AppServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "HandleData",
			Handler:    _App_HandleData_Handler,
		},
		{
			MethodName: "HandleJoin",
			Handler:    _App_HandleJoin_Handler,
		},
	},
	Streams: []grpc.StreamDesc{},
}

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

func (m *DataAppReq) MarshalTo(data []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.AppEUI) > 0 {
		data[i] = 0xa
		i++
		i = encodeVarintApplication(data, i, uint64(len(m.AppEUI)))
		i += copy(data[i:], m.AppEUI)
	}
	if len(m.DevEUI) > 0 {
		data[i] = 0x12
		i++
		i = encodeVarintApplication(data, i, uint64(len(m.DevEUI)))
		i += copy(data[i:], m.DevEUI)
	}
	if m.FPort != 0 {
		data[i] = 0x50
		i++
		i = encodeVarintApplication(data, i, uint64(m.FPort))
	}
	if m.FCnt != 0 {
		data[i] = 0x58
		i++
		i = encodeVarintApplication(data, i, uint64(m.FCnt))
	}
	if len(m.Payload) > 0 {
		data[i] = 0xa2
		i++
		data[i] = 0x1
		i++
		i = encodeVarintApplication(data, i, uint64(len(m.Payload)))
		i += copy(data[i:], m.Payload)
	}
	if len(m.Metadata) > 0 {
		for _, msg := range m.Metadata {
			data[i] = 0xf2
			i++
			data[i] = 0x1
			i++
			i = encodeVarintApplication(data, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(data[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	return i, nil
}

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

func (m *DataAppRes) MarshalTo(data []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	return i, nil
}

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

func (m *JoinAppReq) MarshalTo(data []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.AppEUI) > 0 {
		data[i] = 0xa
		i++
		i = encodeVarintApplication(data, i, uint64(len(m.AppEUI)))
		i += copy(data[i:], m.AppEUI)
	}
	if len(m.DevEUI) > 0 {
		data[i] = 0x12
		i++
		i = encodeVarintApplication(data, i, uint64(len(m.DevEUI)))
		i += copy(data[i:], m.DevEUI)
	}
	if len(m.Metadata) > 0 {
		for _, msg := range m.Metadata {
			data[i] = 0xf2
			i++
			data[i] = 0x1
			i++
			i = encodeVarintApplication(data, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(data[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	return i, nil
}

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

func (m *JoinAppRes) MarshalTo(data []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	return i, nil
}

func encodeFixed64Application(data []byte, offset int, v uint64) int {
	data[offset] = uint8(v)
	data[offset+1] = uint8(v >> 8)
	data[offset+2] = uint8(v >> 16)
	data[offset+3] = uint8(v >> 24)
	data[offset+4] = uint8(v >> 32)
	data[offset+5] = uint8(v >> 40)
	data[offset+6] = uint8(v >> 48)
	data[offset+7] = uint8(v >> 56)
	return offset + 8
}
func encodeFixed32Application(data []byte, offset int, v uint32) int {
	data[offset] = uint8(v)
	data[offset+1] = uint8(v >> 8)
	data[offset+2] = uint8(v >> 16)
	data[offset+3] = uint8(v >> 24)
	return offset + 4
}
func encodeVarintApplication(data []byte, offset int, v uint64) int {
	for v >= 1<<7 {
		data[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	data[offset] = uint8(v)
	return offset + 1
}
func (m *DataAppReq) Size() (n int) {
	var l int
	_ = l
	l = len(m.AppEUI)
	if l > 0 {
		n += 1 + l + sovApplication(uint64(l))
	}
	l = len(m.DevEUI)
	if l > 0 {
		n += 1 + l + sovApplication(uint64(l))
	}
	if m.FPort != 0 {
		n += 1 + sovApplication(uint64(m.FPort))
	}
	if m.FCnt != 0 {
		n += 1 + sovApplication(uint64(m.FCnt))
	}
	l = len(m.Payload)
	if l > 0 {
		n += 2 + l + sovApplication(uint64(l))
	}
	if len(m.Metadata) > 0 {
		for _, e := range m.Metadata {
			l = e.Size()
			n += 2 + l + sovApplication(uint64(l))
		}
	}
	return n
}

func (m *DataAppRes) Size() (n int) {
	var l int
	_ = l
	return n
}

func (m *JoinAppReq) Size() (n int) {
	var l int
	_ = l
	l = len(m.AppEUI)
	if l > 0 {
		n += 1 + l + sovApplication(uint64(l))
	}
	l = len(m.DevEUI)
	if l > 0 {
		n += 1 + l + sovApplication(uint64(l))
	}
	if len(m.Metadata) > 0 {
		for _, e := range m.Metadata {
			l = e.Size()
			n += 2 + l + sovApplication(uint64(l))
		}
	}
	return n
}

func (m *JoinAppRes) Size() (n int) {
	var l int
	_ = l
	return n
}

func sovApplication(x uint64) (n int) {
	for {
		n++
		x >>= 7
		if x == 0 {
			break
		}
	}
	return n
}
func sozApplication(x uint64) (n int) {
	return sovApplication(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *DataAppReq) 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 ErrIntOverflowApplication
			}
			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: DataAppReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DataAppReq: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AppEUI", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApplication
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[iNdEx]
				iNdEx++
				byteLen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthApplication
			}
			postIndex := iNdEx + byteLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.AppEUI = append(m.AppEUI[:0], data[iNdEx:postIndex]...)
			if m.AppEUI == nil {
				m.AppEUI = []byte{}
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DevEUI", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApplication
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[iNdEx]
				iNdEx++
				byteLen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthApplication
			}
			postIndex := iNdEx + byteLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DevEUI = append(m.DevEUI[:0], data[iNdEx:postIndex]...)
			if m.DevEUI == nil {
				m.DevEUI = []byte{}
			}
			iNdEx = postIndex
		case 10:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field FPort", wireType)
			}
			m.FPort = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApplication
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[iNdEx]
				iNdEx++
				m.FPort |= (uint32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 11:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field FCnt", wireType)
			}
			m.FCnt = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApplication
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[iNdEx]
				iNdEx++
				m.FCnt |= (uint32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 20:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Payload", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApplication
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[iNdEx]
				iNdEx++
				byteLen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthApplication
			}
			postIndex := iNdEx + byteLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Payload = append(m.Payload[:0], data[iNdEx:postIndex]...)
			if m.Payload == nil {
				m.Payload = []byte{}
			}
			iNdEx = postIndex
		case 30:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Metadata", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApplication
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthApplication
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Metadata = append(m.Metadata, &Metadata{})
			if err := m.Metadata[len(m.Metadata)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipApplication(data[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthApplication
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *JoinAppReq) 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 ErrIntOverflowApplication
			}
			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: JoinAppReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: JoinAppReq: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AppEUI", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApplication
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[iNdEx]
				iNdEx++
				byteLen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthApplication
			}
			postIndex := iNdEx + byteLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.AppEUI = append(m.AppEUI[:0], data[iNdEx:postIndex]...)
			if m.AppEUI == nil {
				m.AppEUI = []byte{}
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DevEUI", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApplication
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[iNdEx]
				iNdEx++
				byteLen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthApplication
			}
			postIndex := iNdEx + byteLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DevEUI = append(m.DevEUI[:0], data[iNdEx:postIndex]...)
			if m.DevEUI == nil {
				m.DevEUI = []byte{}
			}
			iNdEx = postIndex
		case 30:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Metadata", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApplication
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthApplication
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Metadata = append(m.Metadata, &Metadata{})
			if err := m.Metadata[len(m.Metadata)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipApplication(data[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthApplication
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipApplication(data []byte) (n int, err error) {
	l := len(data)
	iNdEx := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowApplication
			}
			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, ErrIntOverflowApplication
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if data[iNdEx-1] < 0x80 {
					break
				}
			}
			return iNdEx, nil
		case 1:
			iNdEx += 8
			return iNdEx, nil
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowApplication
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := data[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			iNdEx += length
			if length < 0 {
				return 0, ErrInvalidLengthApplication
			}
			return iNdEx, nil
		case 3:
			for {
				var innerWire uint64
				var start int = iNdEx
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return 0, ErrIntOverflowApplication
					}
					if iNdEx >= l {
						return 0, io.ErrUnexpectedEOF
					}
					b := data[iNdEx]
					iNdEx++
					innerWire |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				innerWireType := int(innerWire & 0x7)
				if innerWireType == 4 {
					break
				}
				next, err := skipApplication(data[start:])
				if err != nil {
					return 0, err
				}
				iNdEx = start + next
			}
			return iNdEx, nil
		case 4:
			return iNdEx, nil
		case 5:
			iNdEx += 4
			return iNdEx, nil
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
	}
	panic("unreachable")
}

var (
	ErrInvalidLengthApplication = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowApplication   = fmt.Errorf("proto: integer overflow")
)

var fileDescriptorApplication = []byte{
	// 267 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xe2, 0x12, 0x4c, 0x2c, 0x28, 0xc8,
	0xc9, 0x4c, 0x4e, 0x2c, 0xc9, 0xcc, 0xcf, 0xd3, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x62, 0x49,
	0xce, 0x2f, 0x4a, 0x95, 0xe2, 0x02, 0x91, 0x10, 0x11, 0xa5, 0x35, 0x8c, 0x5c, 0x5c, 0x2e, 0x89,
	0x25, 0x89, 0x8e, 0x05, 0x05, 0x41, 0xa9, 0x85, 0x42, 0x62, 0x5c, 0x6c, 0x40, 0x96, 0x6b, 0xa8,
	0xa7, 0x04, 0xa3, 0x02, 0xa3, 0x06, 0x4f, 0x10, 0x5b, 0x22, 0x98, 0x07, 0x12, 0x77, 0x49, 0x2d,
	0x03, 0x89, 0x33, 0x41, 0xc4, 0x53, 0xc0, 0x3c, 0x21, 0x11, 0x2e, 0x56, 0xb7, 0x80, 0xfc, 0xa2,
	0x12, 0x09, 0x2e, 0xa0, 0x30, 0x6f, 0x10, 0x6b, 0x1a, 0x88, 0x23, 0x24, 0xc4, 0xc5, 0xe2, 0xe6,
	0x9c, 0x57, 0x22, 0xc1, 0x0d, 0x16, 0x64, 0x49, 0x03, 0xb2, 0x85, 0x24, 0xb8, 0xd8, 0x03, 0x12,
	0x2b, 0x73, 0xf2, 0x13, 0x53, 0x24, 0x44, 0xc0, 0x46, 0xb0, 0x17, 0x40, 0xb8, 0x42, 0x5a, 0x5c,
	0x1c, 0xbe, 0xa9, 0x25, 0x89, 0x29, 0x40, 0x57, 0x48, 0xc8, 0x29, 0x30, 0x6b, 0x70, 0x1b, 0xf1,
	0xe9, 0x81, 0x5d, 0x08, 0x13, 0x0d, 0xe2, 0xc8, 0x85, 0xb2, 0x94, 0x78, 0x90, 0x5c, 0x5b, 0xac,
	0x94, 0xc1, 0xc5, 0xe5, 0x95, 0x9f, 0x99, 0x47, 0xa6, 0xdb, 0x49, 0xb4, 0x17, 0x6e, 0x53, 0xb1,
	0x51, 0x26, 0x17, 0x33, 0x90, 0x25, 0x64, 0xc0, 0xc5, 0xe5, 0x91, 0x98, 0x97, 0x92, 0x93, 0x0a,
	0x72, 0x92, 0x90, 0x00, 0x44, 0x33, 0x22, 0x30, 0xa5, 0xd0, 0x45, 0x8a, 0x11, 0x3a, 0x40, 0x86,
	0xc1, 0x74, 0x20, 0xbc, 0x20, 0x85, 0x2e, 0x52, 0xec, 0x24, 0x70, 0xe2, 0x91, 0x1c, 0xe3, 0x05,
	0x20, 0x7e, 0x00, 0xc4, 0x33, 0x1e, 0xcb, 0x31, 0x24, 0xb1, 0x81, 0x23, 0xce, 0x18, 0x10, 0x00,
	0x00, 0xff, 0xff, 0x31, 0xc2, 0xe7, 0xa9, 0xdf, 0x01, 0x00, 0x00,
}