proto.UnmarshalOptions.unmarshalList - Code Metrics - Inspection of "Adding vendor folder" - cdleo/go-sqldb - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed

Push — main ( 973aa1...436074 )

by Christian

created 2022-06-16 19:46 UTC

proto.UnmarshalOptions.unmarshalList F

↳ Parent: vendor/google.golang.org/protobuf/proto/decode_gen.go

Complexity

Conditions

116

Size

Total Lines	405
Code Lines	310

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	116
eloc	310
nop	4
dl	0
loc	405
rs	0
c	0
b	0
f	0

How to fix Long Method Complexity

// Copyright 2018 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Code generated by generate-types. DO NOT EDIT.

package proto

import (
	"math"
	"unicode/utf8"

	"google.golang.org/protobuf/encoding/protowire"
	"google.golang.org/protobuf/internal/errors"
	"google.golang.org/protobuf/internal/strs"
	"google.golang.org/protobuf/reflect/protoreflect"
)

// unmarshalScalar decodes a value of the given kind.
//
// Message values are decoded into a []byte which aliases the input data.
func (o UnmarshalOptions) unmarshalScalar(b []byte, wtyp protowire.Type, fd protoreflect.FieldDescriptor) (val protoreflect.Value, n int, err error) {
	switch fd.Kind() {
	case protoreflect.BoolKind:
		if wtyp != protowire.VarintType {
			return val, 0, errUnknown
		}
		v, n := protowire.ConsumeVarint(b)
		if n < 0 {
			return val, 0, errDecode
		}
		return protoreflect.ValueOfBool(protowire.DecodeBool(v)), n, nil
	case protoreflect.EnumKind:
		if wtyp != protowire.VarintType {
			return val, 0, errUnknown
		}
		v, n := protowire.ConsumeVarint(b)
		if n < 0 {
			return val, 0, errDecode
		}
		return protoreflect.ValueOfEnum(protoreflect.EnumNumber(v)), n, nil
	case protoreflect.Int32Kind:
		if wtyp != protowire.VarintType {
			return val, 0, errUnknown
		}
		v, n := protowire.ConsumeVarint(b)
		if n < 0 {
			return val, 0, errDecode
		}
		return protoreflect.ValueOfInt32(int32(v)), n, nil
	case protoreflect.Sint32Kind:
		if wtyp != protowire.VarintType {
			return val, 0, errUnknown
		}
		v, n := protowire.ConsumeVarint(b)
		if n < 0 {
			return val, 0, errDecode
		}
		return protoreflect.ValueOfInt32(int32(protowire.DecodeZigZag(v & math.MaxUint32))), n, nil
	case protoreflect.Uint32Kind:
		if wtyp != protowire.VarintType {
			return val, 0, errUnknown
		}
		v, n := protowire.ConsumeVarint(b)
		if n < 0 {
			return val, 0, errDecode
		}
		return protoreflect.ValueOfUint32(uint32(v)), n, nil
	case protoreflect.Int64Kind:
		if wtyp != protowire.VarintType {
			return val, 0, errUnknown
		}
		v, n := protowire.ConsumeVarint(b)
		if n < 0 {
			return val, 0, errDecode
		}
		return protoreflect.ValueOfInt64(int64(v)), n, nil
	case protoreflect.Sint64Kind:
		if wtyp != protowire.VarintType {
			return val, 0, errUnknown
		}
		v, n := protowire.ConsumeVarint(b)
		if n < 0 {
			return val, 0, errDecode
		}
		return protoreflect.ValueOfInt64(protowire.DecodeZigZag(v)), n, nil
	case protoreflect.Uint64Kind:
		if wtyp != protowire.VarintType {
			return val, 0, errUnknown
		}
		v, n := protowire.ConsumeVarint(b)
		if n < 0 {
			return val, 0, errDecode
		}
		return protoreflect.ValueOfUint64(v), n, nil
	case protoreflect.Sfixed32Kind:
		if wtyp != protowire.Fixed32Type {
			return val, 0, errUnknown
		}
		v, n := protowire.ConsumeFixed32(b)
		if n < 0 {
			return val, 0, errDecode
		}
		return protoreflect.ValueOfInt32(int32(v)), n, nil
	case protoreflect.Fixed32Kind:
		if wtyp != protowire.Fixed32Type {
			return val, 0, errUnknown
		}
		v, n := protowire.ConsumeFixed32(b)
		if n < 0 {
			return val, 0, errDecode
		}
		return protoreflect.ValueOfUint32(uint32(v)), n, nil
	case protoreflect.FloatKind:
		if wtyp != protowire.Fixed32Type {
			return val, 0, errUnknown
		}
		v, n := protowire.ConsumeFixed32(b)
		if n < 0 {
			return val, 0, errDecode
		}
		return protoreflect.ValueOfFloat32(math.Float32frombits(uint32(v))), n, nil
	case protoreflect.Sfixed64Kind:
		if wtyp != protowire.Fixed64Type {
			return val, 0, errUnknown
		}
		v, n := protowire.ConsumeFixed64(b)
		if n < 0 {
			return val, 0, errDecode
		}
		return protoreflect.ValueOfInt64(int64(v)), n, nil
	case protoreflect.Fixed64Kind:
		if wtyp != protowire.Fixed64Type {
			return val, 0, errUnknown
		}
		v, n := protowire.ConsumeFixed64(b)
		if n < 0 {
			return val, 0, errDecode
		}
		return protoreflect.ValueOfUint64(v), n, nil
	case protoreflect.DoubleKind:
		if wtyp != protowire.Fixed64Type {
			return val, 0, errUnknown
		}
		v, n := protowire.ConsumeFixed64(b)
		if n < 0 {
			return val, 0, errDecode
		}
		return protoreflect.ValueOfFloat64(math.Float64frombits(v)), n, nil
	case protoreflect.StringKind:
		if wtyp != protowire.BytesType {
			return val, 0, errUnknown
		}
		v, n := protowire.ConsumeBytes(b)
		if n < 0 {
			return val, 0, errDecode
		}
		if strs.EnforceUTF8(fd) && !utf8.Valid(v) {
			return protoreflect.Value{}, 0, errors.InvalidUTF8(string(fd.FullName()))
		}
		return protoreflect.ValueOfString(string(v)), n, nil
	case protoreflect.BytesKind:
		if wtyp != protowire.BytesType {
			return val, 0, errUnknown
		}
		v, n := protowire.ConsumeBytes(b)
		if n < 0 {
			return val, 0, errDecode
		}
		return protoreflect.ValueOfBytes(append(emptyBuf[:], v...)), n, nil
	case protoreflect.MessageKind:
		if wtyp != protowire.BytesType {
			return val, 0, errUnknown
		}
		v, n := protowire.ConsumeBytes(b)
		if n < 0 {
			return val, 0, errDecode
		}
		return protoreflect.ValueOfBytes(v), n, nil
	case protoreflect.GroupKind:
		if wtyp != protowire.StartGroupType {
			return val, 0, errUnknown
		}
		v, n := protowire.ConsumeGroup(fd.Number(), b)
		if n < 0 {
			return val, 0, errDecode
		}
		return protoreflect.ValueOfBytes(v), n, nil
	default:
		return val, 0, errUnknown
	}
}

func (o UnmarshalOptions) unmarshalList(b []byte, wtyp protowire.Type, list protoreflect.List, fd protoreflect.FieldDescriptor) (n int, err error) {
	switch fd.Kind() {
	case protoreflect.BoolKind:
		if wtyp == protowire.BytesType {
			buf, n := protowire.ConsumeBytes(b)
			if n < 0 {
				return 0, errDecode
			}
			for len(buf) > 0 {
				v, n := protowire.ConsumeVarint(buf)
				if n < 0 {
					return 0, errDecode
				}
				buf = buf[n:]
				list.Append(protoreflect.ValueOfBool(protowire.DecodeBool(v)))
			}
			return n, nil
		}
		if wtyp != protowire.VarintType {
			return 0, errUnknown
		}
		v, n := protowire.ConsumeVarint(b)
		if n < 0 {
			return 0, errDecode
		}
		list.Append(protoreflect.ValueOfBool(protowire.DecodeBool(v)))
		return n, nil
	case protoreflect.EnumKind:
		if wtyp == protowire.BytesType {
			buf, n := protowire.ConsumeBytes(b)
			if n < 0 {
				return 0, errDecode
			}
			for len(buf) > 0 {
				v, n := protowire.ConsumeVarint(buf)
				if n < 0 {
					return 0, errDecode
				}
				buf = buf[n:]
				list.Append(protoreflect.ValueOfEnum(protoreflect.EnumNumber(v)))
			}
			return n, nil
		}
		if wtyp != protowire.VarintType {
			return 0, errUnknown
		}
		v, n := protowire.ConsumeVarint(b)
		if n < 0 {
			return 0, errDecode
		}
		list.Append(protoreflect.ValueOfEnum(protoreflect.EnumNumber(v)))
		return n, nil
	case protoreflect.Int32Kind:
		if wtyp == protowire.BytesType {
			buf, n := protowire.ConsumeBytes(b)
			if n < 0 {
				return 0, errDecode
			}
			for len(buf) > 0 {
				v, n := protowire.ConsumeVarint(buf)
				if n < 0 {
					return 0, errDecode
				}
				buf = buf[n:]
				list.Append(protoreflect.ValueOfInt32(int32(v)))
			}
			return n, nil
		}
		if wtyp != protowire.VarintType {
			return 0, errUnknown
		}
		v, n := protowire.ConsumeVarint(b)
		if n < 0 {
			return 0, errDecode
		}
		list.Append(protoreflect.ValueOfInt32(int32(v)))
		return n, nil
	case protoreflect.Sint32Kind:
		if wtyp == protowire.BytesType {
			buf, n := protowire.ConsumeBytes(b)
			if n < 0 {
				return 0, errDecode
			}
			for len(buf) > 0 {
				v, n := protowire.ConsumeVarint(buf)
				if n < 0 {
					return 0, errDecode
				}
				buf = buf[n:]
				list.Append(protoreflect.ValueOfInt32(int32(protowire.DecodeZigZag(v & math.MaxUint32))))
			}
			return n, nil
		}
		if wtyp != protowire.VarintType {
			return 0, errUnknown
		}
		v, n := protowire.ConsumeVarint(b)
		if n < 0 {
			return 0, errDecode
		}
		list.Append(protoreflect.ValueOfInt32(int32(protowire.DecodeZigZag(v & math.MaxUint32))))
		return n, nil
	case protoreflect.Uint32Kind:
		if wtyp == protowire.BytesType {
			buf, n := protowire.ConsumeBytes(b)
			if n < 0 {
				return 0, errDecode
			}
			for len(buf) > 0 {
				v, n := protowire.ConsumeVarint(buf)
				if n < 0 {
					return 0, errDecode
				}
				buf = buf[n:]
				list.Append(protoreflect.ValueOfUint32(uint32(v)))
			}
			return n, nil
		}
		if wtyp != protowire.VarintType {
			return 0, errUnknown
		}
		v, n := protowire.ConsumeVarint(b)
		if n < 0 {
			return 0, errDecode
		}
		list.Append(protoreflect.ValueOfUint32(uint32(v)))
		return n, nil
	case protoreflect.Int64Kind:
		if wtyp == protowire.BytesType {
			buf, n := protowire.ConsumeBytes(b)
			if n < 0 {
				return 0, errDecode
			}
			for len(buf) > 0 {
				v, n := protowire.ConsumeVarint(buf)
				if n < 0 {
					return 0, errDecode
				}
				buf = buf[n:]
				list.Append(protoreflect.ValueOfInt64(int64(v)))
			}
			return n, nil
		}
		if wtyp != protowire.VarintType {
			return 0, errUnknown
		}
		v, n := protowire.ConsumeVarint(b)
		if n < 0 {
			return 0, errDecode
		}
		list.Append(protoreflect.ValueOfInt64(int64(v)))
		return n, nil
	case protoreflect.Sint64Kind:
		if wtyp == protowire.BytesType {
			buf, n := protowire.ConsumeBytes(b)
			if n < 0 {
				return 0, errDecode
			}
			for len(buf) > 0 {
				v, n := protowire.ConsumeVarint(buf)
				if n < 0 {
					return 0, errDecode
				}
				buf = buf[n:]
				list.Append(protoreflect.ValueOfInt64(protowire.DecodeZigZag(v)))
			}
			return n, nil
		}
		if wtyp != protowire.VarintType {
			return 0, errUnknown
		}
		v, n := protowire.ConsumeVarint(b)
		if n < 0 {
			return 0, errDecode
		}
		list.Append(protoreflect.ValueOfInt64(protowire.DecodeZigZag(v)))
		return n, nil
	case protoreflect.Uint64Kind:
		if wtyp == protowire.BytesType {
			buf, n := protowire.ConsumeBytes(b)
			if n < 0 {
				return 0, errDecode
			}
			for len(buf) > 0 {
				v, n := protowire.ConsumeVarint(buf)
				if n < 0 {
					return 0, errDecode
				}
				buf = buf[n:]
				list.Append(protoreflect.ValueOfUint64(v))
			}
			return n, nil
		}
		if wtyp != protowire.VarintType {
			return 0, errUnknown
		}
		v, n := protowire.ConsumeVarint(b)
		if n < 0 {
			return 0, errDecode
		}
		list.Append(protoreflect.ValueOfUint64(v))
		return n, nil
	case protoreflect.Sfixed32Kind:
		if wtyp == protowire.BytesType {
			buf, n := protowire.ConsumeBytes(b)
			if n < 0 {
				return 0, errDecode
			}
			for len(buf) > 0 {
				v, n := protowire.ConsumeFixed32(buf)
				if n < 0 {
					return 0, errDecode
				}
				buf = buf[n:]
				list.Append(protoreflect.ValueOfInt32(int32(v)))
			}
			return n, nil
		}
		if wtyp != protowire.Fixed32Type {
			return 0, errUnknown
		}
		v, n := protowire.ConsumeFixed32(b)
		if n < 0 {
			return 0, errDecode
		}
		list.Append(protoreflect.ValueOfInt32(int32(v)))
		return n, nil
	case protoreflect.Fixed32Kind:
		if wtyp == protowire.BytesType {
			buf, n := protowire.ConsumeBytes(b)
			if n < 0 {
				return 0, errDecode
			}
			for len(buf) > 0 {
				v, n := protowire.ConsumeFixed32(buf)
				if n < 0 {
					return 0, errDecode
				}
				buf = buf[n:]
				list.Append(protoreflect.ValueOfUint32(uint32(v)))
			}
			return n, nil
		}
		if wtyp != protowire.Fixed32Type {
			return 0, errUnknown
		}
		v, n := protowire.ConsumeFixed32(b)
		if n < 0 {
			return 0, errDecode
		}
		list.Append(protoreflect.ValueOfUint32(uint32(v)))
		return n, nil
	case protoreflect.FloatKind:
		if wtyp == protowire.BytesType {
			buf, n := protowire.ConsumeBytes(b)
			if n < 0 {
				return 0, errDecode
			}
			for len(buf) > 0 {
				v, n := protowire.ConsumeFixed32(buf)
				if n < 0 {
					return 0, errDecode
				}
				buf = buf[n:]
				list.Append(protoreflect.ValueOfFloat32(math.Float32frombits(uint32(v))))
			}
			return n, nil
		}
		if wtyp != protowire.Fixed32Type {
			return 0, errUnknown
		}
		v, n := protowire.ConsumeFixed32(b)
		if n < 0 {
			return 0, errDecode
		}
		list.Append(protoreflect.ValueOfFloat32(math.Float32frombits(uint32(v))))
		return n, nil
	case protoreflect.Sfixed64Kind:
		if wtyp == protowire.BytesType {
			buf, n := protowire.ConsumeBytes(b)
			if n < 0 {
				return 0, errDecode
			}
			for len(buf) > 0 {
				v, n := protowire.ConsumeFixed64(buf)
				if n < 0 {
					return 0, errDecode
				}
				buf = buf[n:]
				list.Append(protoreflect.ValueOfInt64(int64(v)))
			}
			return n, nil
		}
		if wtyp != protowire.Fixed64Type {
			return 0, errUnknown
		}
		v, n := protowire.ConsumeFixed64(b)
		if n < 0 {
			return 0, errDecode
		}
		list.Append(protoreflect.ValueOfInt64(int64(v)))
		return n, nil
	case protoreflect.Fixed64Kind:
		if wtyp == protowire.BytesType {
			buf, n := protowire.ConsumeBytes(b)
			if n < 0 {
				return 0, errDecode
			}
			for len(buf) > 0 {
				v, n := protowire.ConsumeFixed64(buf)
				if n < 0 {
					return 0, errDecode
				}
				buf = buf[n:]
				list.Append(protoreflect.ValueOfUint64(v))
			}
			return n, nil
		}
		if wtyp != protowire.Fixed64Type {
			return 0, errUnknown
		}
		v, n := protowire.ConsumeFixed64(b)
		if n < 0 {
			return 0, errDecode
		}
		list.Append(protoreflect.ValueOfUint64(v))
		return n, nil
	case protoreflect.DoubleKind:
		if wtyp == protowire.BytesType {
			buf, n := protowire.ConsumeBytes(b)
			if n < 0 {
				return 0, errDecode
			}
			for len(buf) > 0 {
				v, n := protowire.ConsumeFixed64(buf)
				if n < 0 {
					return 0, errDecode
				}
				buf = buf[n:]
				list.Append(protoreflect.ValueOfFloat64(math.Float64frombits(v)))
			}
			return n, nil
		}
		if wtyp != protowire.Fixed64Type {
			return 0, errUnknown
		}
		v, n := protowire.ConsumeFixed64(b)
		if n < 0 {
			return 0, errDecode
		}
		list.Append(protoreflect.ValueOfFloat64(math.Float64frombits(v)))
		return n, nil
	case protoreflect.StringKind:
		if wtyp != protowire.BytesType {
			return 0, errUnknown
		}
		v, n := protowire.ConsumeBytes(b)
		if n < 0 {
			return 0, errDecode
		}
		if strs.EnforceUTF8(fd) && !utf8.Valid(v) {
			return 0, errors.InvalidUTF8(string(fd.FullName()))
		}
		list.Append(protoreflect.ValueOfString(string(v)))
		return n, nil
	case protoreflect.BytesKind:
		if wtyp != protowire.BytesType {
			return 0, errUnknown
		}
		v, n := protowire.ConsumeBytes(b)
		if n < 0 {
			return 0, errDecode
		}
		list.Append(protoreflect.ValueOfBytes(append(emptyBuf[:], v...)))
		return n, nil
	case protoreflect.MessageKind:
		if wtyp != protowire.BytesType {
			return 0, errUnknown
		}
		v, n := protowire.ConsumeBytes(b)
		if n < 0 {
			return 0, errDecode
		}
		m := list.NewElement()
		if err := o.unmarshalMessage(v, m.Message()); err != nil {
			return 0, err
		}
		list.Append(m)
		return n, nil
	case protoreflect.GroupKind:
		if wtyp != protowire.StartGroupType {
			return 0, errUnknown
		}
		v, n := protowire.ConsumeGroup(fd.Number(), b)
		if n < 0 {
			return 0, errDecode
		}
		m := list.NewElement()
		if err := o.unmarshalMessage(v, m.Message()); err != nil {
			return 0, err
		}
		list.Append(m)
		return n, nil
	default:
		return 0, errUnknown
	}
}

// We append to an empty array rather than a nil []byte to get non-nil zero-length byte slices.
var emptyBuf [0]byte


1			// Copyright 2018 The Go Authors. All rights reserved.
2			// Use of this source code is governed by a BSD-style
3			// license that can be found in the LICENSE file.
4
5			// Code generated by generate-types. DO NOT EDIT.
6
7			package proto
8
9			import (
10			"math"
11			"unicode/utf8"
12
13			"google.golang.org/protobuf/encoding/protowire"
14			"google.golang.org/protobuf/internal/errors"
15			"google.golang.org/protobuf/internal/strs"
16			"google.golang.org/protobuf/reflect/protoreflect"
17			)
18
19			// unmarshalScalar decodes a value of the given kind.
20			//
21			// Message values are decoded into a []byte which aliases the input data.
22			func (o UnmarshalOptions) unmarshalScalar(b []byte, wtyp protowire.Type, fd protoreflect.FieldDescriptor) (val protoreflect.Value, n int, err error) {
23			switch fd.Kind() {
24			case protoreflect.BoolKind:
25			if wtyp != protowire.VarintType {
26			return val, 0, errUnknown
27			}
28			v, n := protowire.ConsumeVarint(b)
29			if n < 0 {
30			return val, 0, errDecode
31			}
32			return protoreflect.ValueOfBool(protowire.DecodeBool(v)), n, nil
33			case protoreflect.EnumKind:
34			if wtyp != protowire.VarintType {
35			return val, 0, errUnknown
36			}
37			v, n := protowire.ConsumeVarint(b)
38			if n < 0 {
39			return val, 0, errDecode
40			}
41			return protoreflect.ValueOfEnum(protoreflect.EnumNumber(v)), n, nil
42			case protoreflect.Int32Kind:
43			if wtyp != protowire.VarintType {
44			return val, 0, errUnknown
45			}
46			v, n := protowire.ConsumeVarint(b)
47			if n < 0 {
48			return val, 0, errDecode
49			}
50			return protoreflect.ValueOfInt32(int32(v)), n, nil
51			case protoreflect.Sint32Kind:
52			if wtyp != protowire.VarintType {
53			return val, 0, errUnknown
54			}
55			v, n := protowire.ConsumeVarint(b)
56			if n < 0 {
57			return val, 0, errDecode
58			}
59			return protoreflect.ValueOfInt32(int32(protowire.DecodeZigZag(v & math.MaxUint32))), n, nil
60			case protoreflect.Uint32Kind:
61			if wtyp != protowire.VarintType {
62			return val, 0, errUnknown
63			}
64			v, n := protowire.ConsumeVarint(b)
65			if n < 0 {
66			return val, 0, errDecode
67			}
68			return protoreflect.ValueOfUint32(uint32(v)), n, nil
69			case protoreflect.Int64Kind:
70			if wtyp != protowire.VarintType {
71			return val, 0, errUnknown
72			}
73			v, n := protowire.ConsumeVarint(b)
74			if n < 0 {
75			return val, 0, errDecode
76			}
77			return protoreflect.ValueOfInt64(int64(v)), n, nil
78			case protoreflect.Sint64Kind:
79			if wtyp != protowire.VarintType {
80			return val, 0, errUnknown
81			}
82			v, n := protowire.ConsumeVarint(b)
83			if n < 0 {
84			return val, 0, errDecode
85			}
86			return protoreflect.ValueOfInt64(protowire.DecodeZigZag(v)), n, nil
87			case protoreflect.Uint64Kind:
88			if wtyp != protowire.VarintType {
89			return val, 0, errUnknown
90			}
91			v, n := protowire.ConsumeVarint(b)
92			if n < 0 {
93			return val, 0, errDecode
94			}
95			return protoreflect.ValueOfUint64(v), n, nil
96			case protoreflect.Sfixed32Kind:
97			if wtyp != protowire.Fixed32Type {
98			return val, 0, errUnknown
99			}
100			v, n := protowire.ConsumeFixed32(b)
101			if n < 0 {
102			return val, 0, errDecode
103			}
104			return protoreflect.ValueOfInt32(int32(v)), n, nil
105			case protoreflect.Fixed32Kind:
106			if wtyp != protowire.Fixed32Type {
107			return val, 0, errUnknown
108			}
109			v, n := protowire.ConsumeFixed32(b)
110			if n < 0 {
111			return val, 0, errDecode
112			}
113			return protoreflect.ValueOfUint32(uint32(v)), n, nil
114			case protoreflect.FloatKind:
115			if wtyp != protowire.Fixed32Type {
116			return val, 0, errUnknown
117			}
118			v, n := protowire.ConsumeFixed32(b)
119			if n < 0 {
120			return val, 0, errDecode
121			}
122			return protoreflect.ValueOfFloat32(math.Float32frombits(uint32(v))), n, nil
123			case protoreflect.Sfixed64Kind:
124			if wtyp != protowire.Fixed64Type {
125			return val, 0, errUnknown
126			}
127			v, n := protowire.ConsumeFixed64(b)
128			if n < 0 {
129			return val, 0, errDecode
130			}
131			return protoreflect.ValueOfInt64(int64(v)), n, nil
132			case protoreflect.Fixed64Kind:
133			if wtyp != protowire.Fixed64Type {
134			return val, 0, errUnknown
135			}
136			v, n := protowire.ConsumeFixed64(b)
137			if n < 0 {
138			return val, 0, errDecode
139			}
140			return protoreflect.ValueOfUint64(v), n, nil
141			case protoreflect.DoubleKind:
142			if wtyp != protowire.Fixed64Type {
143			return val, 0, errUnknown
144			}
145			v, n := protowire.ConsumeFixed64(b)
146			if n < 0 {
147			return val, 0, errDecode
148			}
149			return protoreflect.ValueOfFloat64(math.Float64frombits(v)), n, nil
150			case protoreflect.StringKind:
151			if wtyp != protowire.BytesType {
152			return val, 0, errUnknown
153			}
154			v, n := protowire.ConsumeBytes(b)
155			if n < 0 {
156			return val, 0, errDecode
157			}
158			if strs.EnforceUTF8(fd) && !utf8.Valid(v) {
159			return protoreflect.Value{}, 0, errors.InvalidUTF8(string(fd.FullName()))
160			}
161			return protoreflect.ValueOfString(string(v)), n, nil
162			case protoreflect.BytesKind:
163			if wtyp != protowire.BytesType {
164			return val, 0, errUnknown
165			}
166			v, n := protowire.ConsumeBytes(b)
167			if n < 0 {
168			return val, 0, errDecode
169			}
170			return protoreflect.ValueOfBytes(append(emptyBuf[:], v...)), n, nil
171			case protoreflect.MessageKind:
172			if wtyp != protowire.BytesType {
173			return val, 0, errUnknown
174			}
175			v, n := protowire.ConsumeBytes(b)
176			if n < 0 {
177			return val, 0, errDecode
178			}
179			return protoreflect.ValueOfBytes(v), n, nil
180			case protoreflect.GroupKind:
181			if wtyp != protowire.StartGroupType {
182			return val, 0, errUnknown
183			}
184			v, n := protowire.ConsumeGroup(fd.Number(), b)
185			if n < 0 {
186			return val, 0, errDecode
187			}
188			return protoreflect.ValueOfBytes(v), n, nil
189			default:
190			return val, 0, errUnknown
191			}
192			}
193
194			func (o UnmarshalOptions) unmarshalList(b []byte, wtyp protowire.Type, list protoreflect.List, fd protoreflect.FieldDescriptor) (n int, err error) {
195			switch fd.Kind() {
196			case protoreflect.BoolKind:
197			if wtyp == protowire.BytesType {
198			buf, n := protowire.ConsumeBytes(b)
199			if n < 0 {
200			return 0, errDecode
201			}
202			for len(buf) > 0 {
203			v, n := protowire.ConsumeVarint(buf)
204			if n < 0 {
205			return 0, errDecode
206			}
207			buf = buf[n:]
208			list.Append(protoreflect.ValueOfBool(protowire.DecodeBool(v)))
209			}
210			return n, nil
211			}
212			if wtyp != protowire.VarintType {
213			return 0, errUnknown
214			}
215			v, n := protowire.ConsumeVarint(b)
216			if n < 0 {
217			return 0, errDecode
218			}
219			list.Append(protoreflect.ValueOfBool(protowire.DecodeBool(v)))
220			return n, nil
221			case protoreflect.EnumKind:
222			if wtyp == protowire.BytesType {
223			buf, n := protowire.ConsumeBytes(b)
224			if n < 0 {
225			return 0, errDecode
226			}
227			for len(buf) > 0 {
228			v, n := protowire.ConsumeVarint(buf)
229			if n < 0 {
230			return 0, errDecode
231			}
232			buf = buf[n:]
233			list.Append(protoreflect.ValueOfEnum(protoreflect.EnumNumber(v)))
234			}
235			return n, nil
236			}
237			if wtyp != protowire.VarintType {
238			return 0, errUnknown
239			}
240			v, n := protowire.ConsumeVarint(b)
241			if n < 0 {
242			return 0, errDecode
243			}
244			list.Append(protoreflect.ValueOfEnum(protoreflect.EnumNumber(v)))
245			return n, nil
246			case protoreflect.Int32Kind:
247			if wtyp == protowire.BytesType {
248			buf, n := protowire.ConsumeBytes(b)
249			if n < 0 {
250			return 0, errDecode
251			}
252			for len(buf) > 0 {
253			v, n := protowire.ConsumeVarint(buf)
254			if n < 0 {
255			return 0, errDecode
256			}
257			buf = buf[n:]
258			list.Append(protoreflect.ValueOfInt32(int32(v)))
259			}
260			return n, nil
261			}
262			if wtyp != protowire.VarintType {
263			return 0, errUnknown
264			}
265			v, n := protowire.ConsumeVarint(b)
266			if n < 0 {
267			return 0, errDecode
268			}
269			list.Append(protoreflect.ValueOfInt32(int32(v)))
270			return n, nil
271			case protoreflect.Sint32Kind:
272			if wtyp == protowire.BytesType {
273			buf, n := protowire.ConsumeBytes(b)
274			if n < 0 {
275			return 0, errDecode
276			}
277			for len(buf) > 0 {
278			v, n := protowire.ConsumeVarint(buf)
279			if n < 0 {
280			return 0, errDecode
281			}
282			buf = buf[n:]
283			list.Append(protoreflect.ValueOfInt32(int32(protowire.DecodeZigZag(v & math.MaxUint32))))
284			}
285			return n, nil
286			}
287			if wtyp != protowire.VarintType {
288			return 0, errUnknown
289			}
290			v, n := protowire.ConsumeVarint(b)
291			if n < 0 {
292			return 0, errDecode
293			}
294			list.Append(protoreflect.ValueOfInt32(int32(protowire.DecodeZigZag(v & math.MaxUint32))))
295			return n, nil
296			case protoreflect.Uint32Kind:
297			if wtyp == protowire.BytesType {
298			buf, n := protowire.ConsumeBytes(b)
299			if n < 0 {
300			return 0, errDecode
301			}
302			for len(buf) > 0 {
303			v, n := protowire.ConsumeVarint(buf)
304			if n < 0 {
305			return 0, errDecode
306			}
307			buf = buf[n:]
308			list.Append(protoreflect.ValueOfUint32(uint32(v)))
309			}
310			return n, nil
311			}
312			if wtyp != protowire.VarintType {
313			return 0, errUnknown
314			}
315			v, n := protowire.ConsumeVarint(b)
316			if n < 0 {
317			return 0, errDecode
318			}
319			list.Append(protoreflect.ValueOfUint32(uint32(v)))
320			return n, nil
321			case protoreflect.Int64Kind:
322			if wtyp == protowire.BytesType {
323			buf, n := protowire.ConsumeBytes(b)
324			if n < 0 {
325			return 0, errDecode
326			}
327			for len(buf) > 0 {
328			v, n := protowire.ConsumeVarint(buf)
329			if n < 0 {
330			return 0, errDecode
331			}
332			buf = buf[n:]
333			list.Append(protoreflect.ValueOfInt64(int64(v)))
334			}
335			return n, nil
336			}
337			if wtyp != protowire.VarintType {
338			return 0, errUnknown
339			}
340			v, n := protowire.ConsumeVarint(b)
341			if n < 0 {
342			return 0, errDecode
343			}
344			list.Append(protoreflect.ValueOfInt64(int64(v)))
345			return n, nil
346			case protoreflect.Sint64Kind:
347			if wtyp == protowire.BytesType {
348			buf, n := protowire.ConsumeBytes(b)
349			if n < 0 {
350			return 0, errDecode
351			}
352			for len(buf) > 0 {
353			v, n := protowire.ConsumeVarint(buf)
354			if n < 0 {
355			return 0, errDecode
356			}
357			buf = buf[n:]
358			list.Append(protoreflect.ValueOfInt64(protowire.DecodeZigZag(v)))
359			}
360			return n, nil
361			}
362			if wtyp != protowire.VarintType {
363			return 0, errUnknown
364			}
365			v, n := protowire.ConsumeVarint(b)
366			if n < 0 {
367			return 0, errDecode
368			}
369			list.Append(protoreflect.ValueOfInt64(protowire.DecodeZigZag(v)))
370			return n, nil
371			case protoreflect.Uint64Kind:
372			if wtyp == protowire.BytesType {
373			buf, n := protowire.ConsumeBytes(b)
374			if n < 0 {
375			return 0, errDecode
376			}
377			for len(buf) > 0 {
378			v, n := protowire.ConsumeVarint(buf)
379			if n < 0 {
380			return 0, errDecode
381			}
382			buf = buf[n:]
383			list.Append(protoreflect.ValueOfUint64(v))
384			}
385			return n, nil
386			}
387			if wtyp != protowire.VarintType {
388			return 0, errUnknown
389			}
390			v, n := protowire.ConsumeVarint(b)
391			if n < 0 {
392			return 0, errDecode
393			}
394			list.Append(protoreflect.ValueOfUint64(v))
395			return n, nil
396			case protoreflect.Sfixed32Kind:
397			if wtyp == protowire.BytesType {
398			buf, n := protowire.ConsumeBytes(b)
399			if n < 0 {
400			return 0, errDecode
401			}
402			for len(buf) > 0 {
403			v, n := protowire.ConsumeFixed32(buf)
404			if n < 0 {
405			return 0, errDecode
406			}
407			buf = buf[n:]
408			list.Append(protoreflect.ValueOfInt32(int32(v)))
409			}
410			return n, nil
411			}
412			if wtyp != protowire.Fixed32Type {
413			return 0, errUnknown
414			}
415			v, n := protowire.ConsumeFixed32(b)
416			if n < 0 {
417			return 0, errDecode
418			}
419			list.Append(protoreflect.ValueOfInt32(int32(v)))
420			return n, nil
421			case protoreflect.Fixed32Kind:
422			if wtyp == protowire.BytesType {
423			buf, n := protowire.ConsumeBytes(b)
424			if n < 0 {
425			return 0, errDecode
426			}
427			for len(buf) > 0 {
428			v, n := protowire.ConsumeFixed32(buf)
429			if n < 0 {
430			return 0, errDecode
431			}
432			buf = buf[n:]
433			list.Append(protoreflect.ValueOfUint32(uint32(v)))
434			}
435			return n, nil
436			}
437			if wtyp != protowire.Fixed32Type {
438			return 0, errUnknown
439			}
440			v, n := protowire.ConsumeFixed32(b)
441			if n < 0 {
442			return 0, errDecode
443			}
444			list.Append(protoreflect.ValueOfUint32(uint32(v)))
445			return n, nil
446			case protoreflect.FloatKind:
447			if wtyp == protowire.BytesType {
448			buf, n := protowire.ConsumeBytes(b)
449			if n < 0 {
450			return 0, errDecode
451			}
452			for len(buf) > 0 {
453			v, n := protowire.ConsumeFixed32(buf)
454			if n < 0 {
455			return 0, errDecode
456			}
457			buf = buf[n:]
458			list.Append(protoreflect.ValueOfFloat32(math.Float32frombits(uint32(v))))
459			}
460			return n, nil
461			}
462			if wtyp != protowire.Fixed32Type {
463			return 0, errUnknown
464			}
465			v, n := protowire.ConsumeFixed32(b)
466			if n < 0 {
467			return 0, errDecode
468			}
469			list.Append(protoreflect.ValueOfFloat32(math.Float32frombits(uint32(v))))
470			return n, nil
471			case protoreflect.Sfixed64Kind:
472			if wtyp == protowire.BytesType {
473			buf, n := protowire.ConsumeBytes(b)
474			if n < 0 {
475			return 0, errDecode
476			}
477			for len(buf) > 0 {
478			v, n := protowire.ConsumeFixed64(buf)
479			if n < 0 {
480			return 0, errDecode
481			}
482			buf = buf[n:]
483			list.Append(protoreflect.ValueOfInt64(int64(v)))
484			}
485			return n, nil
486			}
487			if wtyp != protowire.Fixed64Type {
488			return 0, errUnknown
489			}
490			v, n := protowire.ConsumeFixed64(b)
491			if n < 0 {
492			return 0, errDecode
493			}
494			list.Append(protoreflect.ValueOfInt64(int64(v)))
495			return n, nil
496			case protoreflect.Fixed64Kind:
497			if wtyp == protowire.BytesType {
498			buf, n := protowire.ConsumeBytes(b)
499			if n < 0 {
500			return 0, errDecode
501			}
502			for len(buf) > 0 {
503			v, n := protowire.ConsumeFixed64(buf)
504			if n < 0 {
505			return 0, errDecode
506			}
507			buf = buf[n:]
508			list.Append(protoreflect.ValueOfUint64(v))
509			}
510			return n, nil
511			}
512			if wtyp != protowire.Fixed64Type {
513			return 0, errUnknown
514			}
515			v, n := protowire.ConsumeFixed64(b)
516			if n < 0 {
517			return 0, errDecode
518			}
519			list.Append(protoreflect.ValueOfUint64(v))
520			return n, nil
521			case protoreflect.DoubleKind:
522			if wtyp == protowire.BytesType {
523			buf, n := protowire.ConsumeBytes(b)
524			if n < 0 {
525			return 0, errDecode
526			}
527			for len(buf) > 0 {
528			v, n := protowire.ConsumeFixed64(buf)
529			if n < 0 {
530			return 0, errDecode
531			}
532			buf = buf[n:]
533			list.Append(protoreflect.ValueOfFloat64(math.Float64frombits(v)))
534			}
535			return n, nil
536			}
537			if wtyp != protowire.Fixed64Type {
538			return 0, errUnknown
539			}
540			v, n := protowire.ConsumeFixed64(b)
541			if n < 0 {
542			return 0, errDecode
543			}
544			list.Append(protoreflect.ValueOfFloat64(math.Float64frombits(v)))
545			return n, nil
546			case protoreflect.StringKind:
547			if wtyp != protowire.BytesType {
548			return 0, errUnknown
549			}
550			v, n := protowire.ConsumeBytes(b)
551			if n < 0 {
552			return 0, errDecode
553			}
554			if strs.EnforceUTF8(fd) && !utf8.Valid(v) {
555			return 0, errors.InvalidUTF8(string(fd.FullName()))
556			}
557			list.Append(protoreflect.ValueOfString(string(v)))
558			return n, nil
559			case protoreflect.BytesKind:
560			if wtyp != protowire.BytesType {
561			return 0, errUnknown
562			}
563			v, n := protowire.ConsumeBytes(b)
564			if n < 0 {
565			return 0, errDecode
566			}
567			list.Append(protoreflect.ValueOfBytes(append(emptyBuf[:], v...)))
568			return n, nil
569			case protoreflect.MessageKind:
570			if wtyp != protowire.BytesType {
571			return 0, errUnknown
572			}
573			v, n := protowire.ConsumeBytes(b)
574			if n < 0 {
575			return 0, errDecode
576			}
577			m := list.NewElement()
578			if err := o.unmarshalMessage(v, m.Message()); err != nil {
579			return 0, err
580			}
581			list.Append(m)
582			return n, nil
583			case protoreflect.GroupKind:
584			if wtyp != protowire.StartGroupType {
585			return 0, errUnknown
586			}
587			v, n := protowire.ConsumeGroup(fd.Number(), b)
588			if n < 0 {
589			return 0, errDecode
590			}
591			m := list.NewElement()
592			if err := o.unmarshalMessage(v, m.Message()); err != nil {
593			return 0, err
594			}
595			list.Append(m)
596			return n, nil
597			default:
598			return 0, errUnknown
599			}
600			}
601
602			// We append to an empty array rather than a nil []byte to get non-nil zero-length byte slices.
603			var emptyBuf [0]byte
604

cdleo / go-sqldb

Push — main ( 973aa1...436074 )

proto.UnmarshalOptions.unmarshalList F

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Complexity

Duplication Side-by-Side

Filter issues like