operation.pb.go

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

package types

import (
	fmt "fmt"
	types "github.com/cosmos/cosmos-sdk/codec/types"
	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 OpType int32

const (
	OpType_TRANSFER                     OpType = 0
	OpType_CHANGE_PARTIES               OpType = 1
	OpType_FEE_TOKEN_MANAGEMENT         OpType = 2
	OpType_CONTRACT_UPGRADE             OpType = 3
	OpType_IDENTITY_DEFAULT_TRANSFER    OpType = 4
	OpType_IDENTITY_AGGREGATED_TRANSFER OpType = 5
	OpType_IDENTITY_GIST_TRANSFER       OpType = 6
	OpType_IDENTITY_STATE_TRANSFER      OpType = 7
	OpType_WORLDCOIN_IDENTITY_TRANSFER  OpType = 8
	OpType_CSCA_ROOT_UPDATE             OpType = 9
)

var OpType_name = map[int32]string{
	0: "TRANSFER",
	1: "CHANGE_PARTIES",
	2: "FEE_TOKEN_MANAGEMENT",
	3: "CONTRACT_UPGRADE",
	4: "IDENTITY_DEFAULT_TRANSFER",
	5: "IDENTITY_AGGREGATED_TRANSFER",
	6: "IDENTITY_GIST_TRANSFER",
	7: "IDENTITY_STATE_TRANSFER",
	8: "WORLDCOIN_IDENTITY_TRANSFER",
	9: "CSCA_ROOT_UPDATE",
}

var OpType_value = map[string]int32{
	"TRANSFER":                     0,
	"CHANGE_PARTIES":               1,
	"FEE_TOKEN_MANAGEMENT":         2,
	"CONTRACT_UPGRADE":             3,
	"IDENTITY_DEFAULT_TRANSFER":    4,
	"IDENTITY_AGGREGATED_TRANSFER": 5,
	"IDENTITY_GIST_TRANSFER":       6,
	"IDENTITY_STATE_TRANSFER":      7,
	"WORLDCOIN_IDENTITY_TRANSFER":  8,
	"CSCA_ROOT_UPDATE":             9,
}

func (x OpType) String() string {
	return proto.EnumName(OpType_name, int32(x))
}

func (OpType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_4615e59ddf669d07, []int{0}
}

type OpStatus int32

const (
	OpStatus_INITIALIZED  OpStatus = 0
	OpStatus_APPROVED     OpStatus = 1
	OpStatus_NOT_APPROVED OpStatus = 2
	OpStatus_SIGNED       OpStatus = 3
)

var OpStatus_name = map[int32]string{
	0: "INITIALIZED",
	1: "APPROVED",
	2: "NOT_APPROVED",
	3: "SIGNED",
}

var OpStatus_value = map[string]int32{
	"INITIALIZED":  0,
	"APPROVED":     1,
	"NOT_APPROVED": 2,
	"SIGNED":       3,
}

func (x OpStatus) String() string {
	return proto.EnumName(OpStatus_name, int32(x))
}

func (OpStatus) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_4615e59ddf669d07, []int{1}
}

type Operation struct {
	// Should be in a hex format 0x...
	Index         string `protobuf:"bytes,1,opt,name=index,proto3" json:"index,omitempty"`
	OperationType OpType `protobuf:"varint,2,opt,name=operationType,proto3,enum=rarimo.rarimocore.rarimocore.OpType" json:"operationType,omitempty"`
	// Corresponding to type details
	Details   *types.Any `protobuf:"bytes,3,opt,name=details,proto3" json:"details,omitempty"`
	Status    OpStatus   `protobuf:"varint,4,opt,name=status,proto3,enum=rarimo.rarimocore.rarimocore.OpStatus" json:"status,omitempty"`
	Creator   string     `protobuf:"bytes,5,opt,name=creator,proto3" json:"creator,omitempty"`
	Timestamp uint64     `protobuf:"varint,6,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
}

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

var xxx_messageInfo_Operation proto.InternalMessageInfo

func (m *Operation) GetIndex() string {
	if m != nil {
		return m.Index
	}
	return ""
}

func (m *Operation) GetOperationType() OpType {
	if m != nil {
		return m.OperationType
	}
	return OpType_TRANSFER
}

func (m *Operation) GetDetails() *types.Any {
	if m != nil {
		return m.Details
	}
	return nil
}

func (m *Operation) GetStatus() OpStatus {
	if m != nil {
		return m.Status
	}
	return OpStatus_INITIALIZED
}

func (m *Operation) GetCreator() string {
	if m != nil {
		return m.Creator
	}
	return ""
}

func (m *Operation) GetTimestamp() uint64 {
	if m != nil {
		return m.Timestamp
	}
	return 0
}

func init() {
	proto.RegisterEnum("rarimo.rarimocore.rarimocore.OpType", OpType_name, OpType_value)
	proto.RegisterEnum("rarimo.rarimocore.rarimocore.OpStatus", OpStatus_name, OpStatus_value)
	proto.RegisterType((*Operation)(nil), "rarimo.rarimocore.rarimocore.Operation")
}

func init() { proto.RegisterFile("rarimocore/operation.proto", fileDescriptor_4615e59ddf669d07) }

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

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

func (m *Operation) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Timestamp != 0 {
		i = encodeVarintOperation(dAtA, i, uint64(m.Timestamp))
		i--
		dAtA[i] = 0x30
	}
	if len(m.Creator) > 0 {
		i -= len(m.Creator)
		copy(dAtA[i:], m.Creator)
		i = encodeVarintOperation(dAtA, i, uint64(len(m.Creator)))
		i--
		dAtA[i] = 0x2a
	}
	if m.Status != 0 {
		i = encodeVarintOperation(dAtA, i, uint64(m.Status))
		i--
		dAtA[i] = 0x20
	}
	if m.Details != nil {
		{
			size, err := m.Details.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintOperation(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.OperationType != 0 {
		i = encodeVarintOperation(dAtA, i, uint64(m.OperationType))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Index) > 0 {
		i -= len(m.Index)
		copy(dAtA[i:], m.Index)
		i = encodeVarintOperation(dAtA, i, uint64(len(m.Index)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func encodeVarintOperation(dAtA []byte, offset int, v uint64) int {
	offset -= sovOperation(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *Operation) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Index)
	if l > 0 {
		n += 1 + l + sovOperation(uint64(l))
	}
	if m.OperationType != 0 {
		n += 1 + sovOperation(uint64(m.OperationType))
	}
	if m.Details != nil {
		l = m.Details.Size()
		n += 1 + l + sovOperation(uint64(l))
	}
	if m.Status != 0 {
		n += 1 + sovOperation(uint64(m.Status))
	}
	l = len(m.Creator)
	if l > 0 {
		n += 1 + l + sovOperation(uint64(l))
	}
	if m.Timestamp != 0 {
		n += 1 + sovOperation(uint64(m.Timestamp))
	}
	return n
}

func sovOperation(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozOperation(x uint64) (n int) {
	return sovOperation(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *Operation) 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 ErrIntOverflowOperation
			}
			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: Operation: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Operation: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOperation
				}
				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 ErrInvalidLengthOperation
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthOperation
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Index = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field OperationType", wireType)
			}
			m.OperationType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOperation
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.OperationType |= OpType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Details", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOperation
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthOperation
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthOperation
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Details == nil {
				m.Details = &types.Any{}
			}
			if err := m.Details.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
			}
			m.Status = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOperation
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Status |= OpStatus(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Creator", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOperation
				}
				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 ErrInvalidLengthOperation
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthOperation
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Creator = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType)
			}
			m.Timestamp = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOperation
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Timestamp |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipOperation(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthOperation
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

var (
	ErrInvalidLengthOperation        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowOperation          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupOperation = fmt.Errorf("proto: unexpected end of group")
)