proto_legacy_profile.pb.go

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

package rms

import (
	fmt "fmt"
	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
	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

type Profile struct {
	Address     string      `protobuf:"bytes,1,opt,name=Address,proto3" json:"Address,omitempty"`
	Ref         Reference   `protobuf:"bytes,2,opt,name=Ref,proto3" json:"Ref"`
	ShortID     ShortNodeID `protobuf:"varint,3,opt,name=ShortID,proto3,casttype=ShortNodeID" json:"ShortID"`
	PrimaryRole PrimaryRole `protobuf:"varint,4,opt,name=PrimaryRole,proto3,casttype=PrimaryRole" json:"PrimaryRole"`
	SpecialRole SpecialRole `protobuf:"varint,5,opt,name=SpecialRole,proto3,casttype=SpecialRole" json:"SpecialRole"`
	Digest      []byte      `protobuf:"bytes,6,opt,name=Digest,proto3" json:"Digest,omitempty"`
	Signature   []byte      `protobuf:"bytes,7,opt,name=Signature,proto3" json:"Signature,omitempty"`
	PublicKey   []byte      `protobuf:"bytes,8,opt,name=PublicKey,proto3" json:"PublicKey,omitempty"`
}

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

var xxx_messageInfo_Profile proto.InternalMessageInfo

func init() {
	proto.RegisterType((*Profile)(nil), "rms.Profile")
}

func init() { proto.RegisterFile("proto_legacy_profile.proto", fileDescriptor_8714009e2f158a6c) }

var fileDescriptor_8714009e2f158a6c = []byte{
	// 332 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x5c, 0x90, 0xc1, 0x6a, 0xea, 0x40,
	0x14, 0x86, 0x67, 0xd4, 0x6b, 0xae, 0xe3, 0xbd, 0x77, 0x31, 0x17, 0xca, 0x20, 0x65, 0x0c, 0x5d,
	0x94, 0x6c, 0x54, 0x68, 0xe9, 0x03, 0x54, 0xdc, 0x48, 0xa1, 0xc8, 0xf8, 0x00, 0x92, 0xc4, 0x93,
	0x38, 0x90, 0x38, 0x32, 0x49, 0x16, 0xbe, 0x45, 0x1f, 0xa1, 0x0f, 0xd2, 0x07, 0x70, 0xe9, 0xd2,
	0x95, 0xd4, 0xe4, 0x25, 0x4a, 0x57, 0x25, 0x93, 0x5a, 0x6d, 0x77, 0xe7, 0xfb, 0xbf, 0xf3, 0xcf,
	0xc0, 0x21, 0x9d, 0x95, 0x56, 0xa9, 0x9a, 0x45, 0x10, 0xba, 0xfe, 0x7a, 0xb6, 0xd2, 0x2a, 0x90,
	0x11, 0xf4, 0x4d, 0x48, 0xeb, 0x3a, 0x4e, 0x3a, 0xbd, 0x50, 0xa6, 0x8b, 0xcc, 0xeb, 0xfb, 0x2a,
	0x1e, 0x84, 0x2a, 0x54, 0x03, 0xe3, 0xbc, 0x2c, 0x30, 0x64, 0xc0, 0x4c, 0x55, 0xa7, 0xd3, 0xd2,
	0x71, 0x52, 0x8d, 0x57, 0x2f, 0x35, 0x62, 0x4d, 0xaa, 0x07, 0x29, 0x23, 0xd6, 0xfd, 0x7c, 0xae,
	0x21, 0x49, 0x18, 0xb6, 0xb1, 0xd3, 0x12, 0x47, 0xa4, 0xd7, 0xa4, 0x2e, 0x20, 0x60, 0x35, 0x1b,
	0x3b, 0xed, 0x9b, 0x7f, 0xfd, 0xb2, 0x2e, 0x20, 0x00, 0x0d, 0x4b, 0x1f, 0x86, 0x8d, 0xcd, 0xbe,
	0x8b, 0x44, 0xb9, 0x40, 0x7b, 0xc4, 0x9a, 0x2e, 0x94, 0x4e, 0xc7, 0x23, 0x56, 0xb7, 0xb1, 0xf3,
	0x77, 0xf8, 0xbf, 0x74, 0xef, 0xfb, 0x6e, 0xdb, 0xc4, 0x8f, 0x6a, 0x0e, 0xe3, 0x91, 0x38, 0xee,
	0xd0, 0x3b, 0xd2, 0x9e, 0x68, 0x19, 0xbb, 0x7a, 0x2d, 0x54, 0x04, 0xac, 0xf1, 0xbd, 0x72, 0xa6,
	0xc4, 0x39, 0x94, 0xb5, 0xe9, 0x0a, 0x7c, 0xe9, 0x46, 0xa6, 0xf6, 0xeb, 0xc7, 0x4f, 0x27, 0x25,
	0xce, 0x81, 0x5e, 0x90, 0xe6, 0x48, 0x86, 0x90, 0xa4, 0xac, 0x69, 0x63, 0xe7, 0x8f, 0xf8, 0x24,
	0x7a, 0x49, 0x5a, 0x53, 0x19, 0x2e, 0xdd, 0x34, 0xd3, 0xc0, 0x2c, 0xa3, 0x4e, 0x41, 0x69, 0x27,
	0x99, 0x17, 0x49, 0xff, 0x01, 0xd6, 0xec, 0x77, 0x65, 0xbf, 0x82, 0xa1, 0xb3, 0x39, 0x70, 0xf4,
	0x76, 0xe0, 0x68, 0x93, 0x73, 0xbc, 0xcd, 0x39, 0xde, 0xe5, 0x1c, 0xbf, 0xe6, 0x1c, 0x3d, 0x15,
	0x1c, 0x3d, 0x17, 0x1c, 0x6f, 0x0b, 0x8e, 0x76, 0x05, 0x47, 0x5e, 0xd3, 0xdc, 0xfb, 0xf6, 0x23,
	0x00, 0x00, 0xff, 0xff, 0x93, 0xa7, 0x20, 0x9b, 0xcc, 0x01, 0x00, 0x00,
}

func (m *Profile) Marshal() (dAtA []byte, err error) {
	size := m.ProtoSize()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	if n != size {
		panic("illegal state")
	}
	return dAtA[:n], nil
}

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

func (m *Profile) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l, fieldEnd int
	_, _ = l, fieldEnd
	if len(m.PublicKey) > 0 {
		i -= len(m.PublicKey)
		copy(dAtA[i:], m.PublicKey)
		i = encodeVarintProtoLegacyProfile(dAtA, i, uint64(len(m.PublicKey)))
		i--
		dAtA[i] = 0x42
	}
	if len(m.Signature) > 0 {
		i -= len(m.Signature)
		copy(dAtA[i:], m.Signature)
		i = encodeVarintProtoLegacyProfile(dAtA, i, uint64(len(m.Signature)))
		i--
		dAtA[i] = 0x3a
	}
	if len(m.Digest) > 0 {
		i -= len(m.Digest)
		copy(dAtA[i:], m.Digest)
		i = encodeVarintProtoLegacyProfile(dAtA, i, uint64(len(m.Digest)))
		i--
		dAtA[i] = 0x32
	}
	if m.SpecialRole != 0 {
		i = encodeVarintProtoLegacyProfile(dAtA, i, uint64(m.SpecialRole))
		i--
		dAtA[i] = 0x28
	}
	if m.PrimaryRole != 0 {
		i = encodeVarintProtoLegacyProfile(dAtA, i, uint64(m.PrimaryRole))
		i--
		dAtA[i] = 0x20
	}
	if m.ShortID != 0 {
		i = encodeVarintProtoLegacyProfile(dAtA, i, uint64(m.ShortID))
		i--
		dAtA[i] = 0x18
	}
	{
		size, err := m.Ref.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintProtoLegacyProfile(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if len(m.Address) > 0 {
		i -= len(m.Address)
		copy(dAtA[i:], m.Address)
		i = encodeVarintProtoLegacyProfile(dAtA, i, uint64(len(m.Address)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func encodeVarintProtoLegacyProfile(dAtA []byte, offset int, v uint64) int {
	offset -= sovProtoLegacyProfile(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}

func (m *Profile) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Address)
	if l > 0 {
		n += 1 + l + sovProtoLegacyProfile(uint64(l))
	}
	l = m.Ref.ProtoSize()
	n += 1 + l + sovProtoLegacyProfile(uint64(l))
	if m.ShortID != 0 {
		n += 1 + sovProtoLegacyProfile(uint64(m.ShortID))
	}
	if m.PrimaryRole != 0 {
		n += 1 + sovProtoLegacyProfile(uint64(m.PrimaryRole))
	}
	if m.SpecialRole != 0 {
		n += 1 + sovProtoLegacyProfile(uint64(m.SpecialRole))
	}
	l = len(m.Digest)
	if l > 0 {
		n += 1 + l + sovProtoLegacyProfile(uint64(l))
	}
	l = len(m.Signature)
	if l > 0 {
		n += 1 + l + sovProtoLegacyProfile(uint64(l))
	}
	l = len(m.PublicKey)
	if l > 0 {
		n += 1 + l + sovProtoLegacyProfile(uint64(l))
	}
	return n
}

func sovProtoLegacyProfile(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozProtoLegacyProfile(x uint64) (n int) {
	return sovProtoLegacyProfile(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *Profile) Unmarshal(dAtA []byte) error {
	_, err := m.UnmarshalWithUnknownCallback(dAtA, skipProtoLegacyProfile)
	return err
}
func (m *Profile) UnmarshalWithUnknownCallback(dAtA []byte, skipFn func([]byte) (int, error)) (int, error) {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		err := func() error {
			var wire uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProtoLegacyProfile
				}
				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: Profile: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
				return fmt.Errorf("proto: Profile: illegal tag %d (wire type %d)", fieldNum, wire)
			}
			switch fieldNum {
			case 1:
				if wireType != 2 {
					return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType)
				}
				var stringLen uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowProtoLegacyProfile
					}
					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 ErrInvalidLengthProtoLegacyProfile
				}
				postIndex := iNdEx + intStringLen
				if postIndex < 0 {
					return ErrInvalidLengthProtoLegacyProfile
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				m.Address = string(dAtA[iNdEx:postIndex])
				iNdEx = postIndex
			case 2:
				if wireType != 2 {
					return fmt.Errorf("proto: wrong wireType = %d for field Ref", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowProtoLegacyProfile
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return ErrInvalidLengthProtoLegacyProfile
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return ErrInvalidLengthProtoLegacyProfile
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				if err := m.Ref.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
					return err
				}
				iNdEx = postIndex
			case 3:
				if wireType != 0 {
					return fmt.Errorf("proto: wrong wireType = %d for field ShortID", wireType)
				}
				m.ShortID = 0
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowProtoLegacyProfile
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					m.ShortID |= ShortNodeID(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
			case 4:
				if wireType != 0 {
					return fmt.Errorf("proto: wrong wireType = %d for field PrimaryRole", wireType)
				}
				m.PrimaryRole = 0
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowProtoLegacyProfile
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					m.PrimaryRole |= PrimaryRole(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
			case 5:
				if wireType != 0 {
					return fmt.Errorf("proto: wrong wireType = %d for field SpecialRole", wireType)
				}
				m.SpecialRole = 0
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowProtoLegacyProfile
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					m.SpecialRole |= SpecialRole(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
			case 6:
				if wireType != 2 {
					return fmt.Errorf("proto: wrong wireType = %d for field Digest", wireType)
				}
				var byteLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowProtoLegacyProfile
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					byteLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if byteLen < 0 {
					return ErrInvalidLengthProtoLegacyProfile
				}
				postIndex := iNdEx + byteLen
				if postIndex < 0 {
					return ErrInvalidLengthProtoLegacyProfile
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				m.Digest = append(m.Digest[:0], dAtA[iNdEx:postIndex]...)
				if m.Digest == nil {
					m.Digest = []byte{}
				}
				iNdEx = postIndex
			case 7:
				if wireType != 2 {
					return fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType)
				}
				var byteLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowProtoLegacyProfile
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					byteLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if byteLen < 0 {
					return ErrInvalidLengthProtoLegacyProfile
				}
				postIndex := iNdEx + byteLen
				if postIndex < 0 {
					return ErrInvalidLengthProtoLegacyProfile
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				m.Signature = append(m.Signature[:0], dAtA[iNdEx:postIndex]...)
				if m.Signature == nil {
					m.Signature = []byte{}
				}
				iNdEx = postIndex
			case 8:
				if wireType != 2 {
					return fmt.Errorf("proto: wrong wireType = %d for field PublicKey", wireType)
				}
				var byteLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowProtoLegacyProfile
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					byteLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if byteLen < 0 {
					return ErrInvalidLengthProtoLegacyProfile
				}
				postIndex := iNdEx + byteLen
				if postIndex < 0 {
					return ErrInvalidLengthProtoLegacyProfile
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				m.PublicKey = append(m.PublicKey[:0], dAtA[iNdEx:postIndex]...)
				if m.PublicKey == nil {
					m.PublicKey = []byte{}
				}
				iNdEx = postIndex
			default:
				iNdEx = preIndex
				skippy, err := skipFn(dAtA[iNdEx:])
				if err != nil {
					return err
				}
				if skippy < 0 {
					l = iNdEx
					break
				}
				if skippy == 0 {
					if skippy, err = skipProtoLegacyProfile(dAtA[iNdEx:]); err != nil {
						return err
					}
				}
				if (iNdEx + skippy) < 0 {
					return ErrInvalidLengthProtoLegacyProfile
				}
				if (iNdEx + skippy) > l {
					return io.ErrUnexpectedEOF
				}
				iNdEx += skippy
			}
			return nil
		}()
		if err != nil {
			return preIndex, err
		}
	}

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

var (
	ErrInvalidLengthProtoLegacyProfile        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowProtoLegacyProfile          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupProtoLegacyProfile = fmt.Errorf("proto: unexpected end of group")
	ErrExpectedBinaryMarkerProtoLegacyProfile = fmt.Errorf("proto: binary marker was expected")
)