all: use typed variant of protoreflect.ValueOf
Change-Id: I7479632b57e7c8efade12a2eb2b855e9c321adb1
Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/196037
Reviewed-by: Damien Neil <dneil@google.com>
diff --git a/encoding/bench_test.go b/encoding/bench_test.go
index d5ae728..d5ac0c3 100644
--- a/encoding/bench_test.go
+++ b/encoding/bench_test.go
@@ -24,14 +24,7 @@
var benchV1 = flag.Bool("v1", false, "benchmark the v1 implementation")
-const (
- boolValue = true
- intValue = 1 << 30
- floatValue = 3.14159265
- strValue = "hello world"
-
- maxRecurseLevel = 3
-)
+const maxRecurseLevel = 3
func makeProto() *tpb.TestAllTypes {
m := &tpb.TestAllTypes{}
@@ -72,34 +65,34 @@
func scalarField(kind pref.Kind) pref.Value {
switch kind {
case pref.BoolKind:
- return pref.ValueOf(boolValue)
+ return pref.ValueOfBool(true)
case pref.Int32Kind, pref.Sint32Kind, pref.Sfixed32Kind:
- return pref.ValueOf(int32(intValue))
+ return pref.ValueOfInt32(1 << 30)
case pref.Int64Kind, pref.Sint64Kind, pref.Sfixed64Kind:
- return pref.ValueOf(int64(intValue))
+ return pref.ValueOfInt64(1 << 30)
case pref.Uint32Kind, pref.Fixed32Kind:
- return pref.ValueOf(uint32(intValue))
+ return pref.ValueOfUint32(1 << 30)
case pref.Uint64Kind, pref.Fixed64Kind:
- return pref.ValueOf(uint64(intValue))
+ return pref.ValueOfUint64(1 << 30)
case pref.FloatKind:
- return pref.ValueOf(float32(floatValue))
+ return pref.ValueOfFloat32(3.14159265)
case pref.DoubleKind:
- return pref.ValueOf(float64(floatValue))
+ return pref.ValueOfFloat64(3.14159265)
case pref.BytesKind:
- return pref.ValueOf([]byte(strValue))
+ return pref.ValueOfBytes([]byte("hello world"))
case pref.StringKind:
- return pref.ValueOf(strValue)
+ return pref.ValueOfString("hello world")
case pref.EnumKind:
- return pref.ValueOf(pref.EnumNumber(42))
+ return pref.ValueOfEnum(42)
}
panic(fmt.Sprintf("FieldDescriptor.Kind %v is not valid", kind))
diff --git a/encoding/protojson/decode.go b/encoding/protojson/decode.go
index 799dc1d..ec32c48 100644
--- a/encoding/protojson/decode.go
+++ b/encoding/protojson/decode.go
@@ -345,7 +345,7 @@
return pref.Value{}, unexpectedJSONError{jval}
}
b, err := jval.Bool()
- return pref.ValueOf(b), err
+ return pref.ValueOfBool(b), err
}
func unmarshalInt(jval json.Value, bitSize int) (pref.Value, error) {
@@ -375,9 +375,9 @@
return pref.Value{}, err
}
if bitSize == 32 {
- return pref.ValueOf(int32(n)), nil
+ return pref.ValueOfInt32(int32(n)), nil
}
- return pref.ValueOf(n), nil
+ return pref.ValueOfInt64(n), nil
}
func unmarshalUint(jval json.Value, bitSize int) (pref.Value, error) {
@@ -407,9 +407,9 @@
return pref.Value{}, err
}
if bitSize == 32 {
- return pref.ValueOf(uint32(n)), nil
+ return pref.ValueOfUint32(uint32(n)), nil
}
- return pref.ValueOf(n), nil
+ return pref.ValueOfUint64(n), nil
}
func unmarshalFloat(jval json.Value, bitSize int) (pref.Value, error) {
@@ -422,19 +422,19 @@
switch s {
case "NaN":
if bitSize == 32 {
- return pref.ValueOf(float32(math.NaN())), nil
+ return pref.ValueOfFloat32(float32(math.NaN())), nil
}
- return pref.ValueOf(math.NaN()), nil
+ return pref.ValueOfFloat64(math.NaN()), nil
case "Infinity":
if bitSize == 32 {
- return pref.ValueOf(float32(math.Inf(+1))), nil
+ return pref.ValueOfFloat32(float32(math.Inf(+1))), nil
}
- return pref.ValueOf(math.Inf(+1)), nil
+ return pref.ValueOfFloat64(math.Inf(+1)), nil
case "-Infinity":
if bitSize == 32 {
- return pref.ValueOf(float32(math.Inf(-1))), nil
+ return pref.ValueOfFloat32(float32(math.Inf(-1))), nil
}
- return pref.ValueOf(math.Inf(-1)), nil
+ return pref.ValueOfFloat64(math.Inf(-1)), nil
}
// Decode number from string.
if len(s) != len(strings.TrimSpace(s)) {
@@ -456,16 +456,16 @@
return pref.Value{}, err
}
if bitSize == 32 {
- return pref.ValueOf(float32(n)), nil
+ return pref.ValueOfFloat32(float32(n)), nil
}
- return pref.ValueOf(n), nil
+ return pref.ValueOfFloat64(n), nil
}
func unmarshalString(jval json.Value) (pref.Value, error) {
if jval.Type() != json.String {
return pref.Value{}, unexpectedJSONError{jval}
}
- return pref.ValueOf(jval.String()), nil
+ return pref.ValueOfString(jval.String()), nil
}
func unmarshalBytes(jval json.Value) (pref.Value, error) {
@@ -485,7 +485,7 @@
if err != nil {
return pref.Value{}, err
}
- return pref.ValueOf(b), nil
+ return pref.ValueOfBytes(b), nil
}
func unmarshalEnum(jval json.Value, fd pref.FieldDescriptor) (pref.Value, error) {
@@ -494,7 +494,7 @@
// Lookup EnumNumber based on name.
s := jval.String()
if enumVal := fd.Enum().Values().ByName(pref.Name(s)); enumVal != nil {
- return pref.ValueOf(enumVal.Number()), nil
+ return pref.ValueOfEnum(enumVal.Number()), nil
}
return pref.Value{}, newError("invalid enum value %q", jval)
@@ -503,12 +503,12 @@
if err != nil {
return pref.Value{}, err
}
- return pref.ValueOf(pref.EnumNumber(n)), nil
+ return pref.ValueOfEnum(pref.EnumNumber(n)), nil
case json.Null:
// This is only valid for google.protobuf.NullValue.
if isNullValue(fd) {
- return pref.ValueOf(pref.EnumNumber(0)), nil
+ return pref.ValueOfEnum(0), nil
}
}
@@ -640,14 +640,14 @@
kind := fd.Kind()
switch kind {
case pref.StringKind:
- return pref.ValueOf(name).MapKey(), nil
+ return pref.ValueOfString(name).MapKey(), nil
case pref.BoolKind:
switch name {
case "true":
- return pref.ValueOf(true).MapKey(), nil
+ return pref.ValueOfBool(true).MapKey(), nil
case "false":
- return pref.ValueOf(false).MapKey(), nil
+ return pref.ValueOfBool(false).MapKey(), nil
}
return pref.MapKey{}, errors.New("invalid value for boolean key %q", name)
@@ -656,28 +656,28 @@
if err != nil {
return pref.MapKey{}, err
}
- return pref.ValueOf(int32(n)).MapKey(), nil
+ return pref.ValueOfInt32(int32(n)).MapKey(), nil
case pref.Int64Kind, pref.Sint64Kind, pref.Sfixed64Kind:
n, err := strconv.ParseInt(name, base10, b64)
if err != nil {
return pref.MapKey{}, err
}
- return pref.ValueOf(int64(n)).MapKey(), nil
+ return pref.ValueOfInt64(int64(n)).MapKey(), nil
case pref.Uint32Kind, pref.Fixed32Kind:
n, err := strconv.ParseUint(name, base10, b32)
if err != nil {
return pref.MapKey{}, err
}
- return pref.ValueOf(uint32(n)).MapKey(), nil
+ return pref.ValueOfUint32(uint32(n)).MapKey(), nil
case pref.Uint64Kind, pref.Fixed64Kind:
n, err := strconv.ParseUint(name, base10, b64)
if err != nil {
return pref.MapKey{}, err
}
- return pref.ValueOf(uint64(n)).MapKey(), nil
+ return pref.ValueOfUint64(uint64(n)).MapKey(), nil
}
panic(fmt.Sprintf("%s: invalid kind %s for map key", fd.FullName(), kind))
diff --git a/encoding/protojson/well_known_types.go b/encoding/protojson/well_known_types.go
index 98094b5..a30b590 100644
--- a/encoding/protojson/well_known_types.go
+++ b/encoding/protojson/well_known_types.go
@@ -261,8 +261,8 @@
fdType := fds.ByNumber(fieldnum.Any_TypeUrl)
fdValue := fds.ByNumber(fieldnum.Any_Value)
- m.Set(fdType, pref.ValueOf(typeURL))
- m.Set(fdValue, pref.ValueOf(b))
+ m.Set(fdType, pref.ValueOfString(typeURL))
+ m.Set(fdValue, pref.ValueOfBytes(b))
return nil
}
@@ -541,7 +541,7 @@
case json.Null:
o.decoder.Read()
fd := m.Descriptor().Fields().ByNumber(fieldnum.Value_NullValue)
- m.Set(fd, pref.ValueOf(pref.EnumNumber(0)))
+ m.Set(fd, pref.ValueOfEnum(0))
case json.Bool:
jval, err := o.decoder.Read()
@@ -687,8 +687,8 @@
fdSeconds := fds.ByNumber(fieldnum.Duration_Seconds)
fdNanos := fds.ByNumber(fieldnum.Duration_Nanos)
- m.Set(fdSeconds, pref.ValueOf(secs))
- m.Set(fdNanos, pref.ValueOf(nanos))
+ m.Set(fdSeconds, pref.ValueOfInt64(secs))
+ m.Set(fdNanos, pref.ValueOfInt32(nanos))
return nil
}
@@ -871,8 +871,8 @@
fdSeconds := fds.ByNumber(fieldnum.Timestamp_Seconds)
fdNanos := fds.ByNumber(fieldnum.Timestamp_Nanos)
- m.Set(fdSeconds, pref.ValueOf(secs))
- m.Set(fdNanos, pref.ValueOf(int32(t.Nanosecond())))
+ m.Set(fdSeconds, pref.ValueOfInt64(secs))
+ m.Set(fdNanos, pref.ValueOfInt32(int32(t.Nanosecond())))
return nil
}
@@ -921,7 +921,7 @@
s = strings.TrimSpace(s)
// Convert to snake_case. Unlike encoding, no validation is done because
// it is not possible to know the original path names.
- list.Append(pref.ValueOf(strs.JSONSnakeCase(s)))
+ list.Append(pref.ValueOfString(strs.JSONSnakeCase(s)))
}
return nil
}
diff --git a/encoding/prototext/decode.go b/encoding/prototext/decode.go
index 2f2a0e9..27d23d3 100644
--- a/encoding/prototext/decode.go
+++ b/encoding/prototext/decode.go
@@ -256,53 +256,53 @@
switch kind := fd.Kind(); kind {
case pref.BoolKind:
if b, ok := input.Bool(); ok {
- return pref.ValueOf(bool(b)), nil
+ return pref.ValueOfBool(bool(b)), nil
}
case pref.Int32Kind, pref.Sint32Kind, pref.Sfixed32Kind:
if n, ok := input.Int(b32); ok {
- return pref.ValueOf(int32(n)), nil
+ return pref.ValueOfInt32(int32(n)), nil
}
case pref.Int64Kind, pref.Sint64Kind, pref.Sfixed64Kind:
if n, ok := input.Int(b64); ok {
- return pref.ValueOf(int64(n)), nil
+ return pref.ValueOfInt64(int64(n)), nil
}
case pref.Uint32Kind, pref.Fixed32Kind:
if n, ok := input.Uint(b32); ok {
- return pref.ValueOf(uint32(n)), nil
+ return pref.ValueOfUint32(uint32(n)), nil
}
case pref.Uint64Kind, pref.Fixed64Kind:
if n, ok := input.Uint(b64); ok {
- return pref.ValueOf(uint64(n)), nil
+ return pref.ValueOfUint64(uint64(n)), nil
}
case pref.FloatKind:
if n, ok := input.Float(b32); ok {
- return pref.ValueOf(float32(n)), nil
+ return pref.ValueOfFloat32(float32(n)), nil
}
case pref.DoubleKind:
if n, ok := input.Float(b64); ok {
- return pref.ValueOf(float64(n)), nil
+ return pref.ValueOfFloat64(float64(n)), nil
}
case pref.StringKind:
if input.Type() == text.String {
s := input.String()
if utf8.ValidString(s) {
- return pref.ValueOf(s), nil
+ return pref.ValueOfString(s), nil
}
return pref.Value{}, errors.InvalidUTF8(string(fd.FullName()))
}
case pref.BytesKind:
if input.Type() == text.String {
- return pref.ValueOf([]byte(input.String())), nil
+ return pref.ValueOfBytes([]byte(input.String())), nil
}
case pref.EnumKind:
// If input is int32, use directly.
if n, ok := input.Int(b32); ok {
- return pref.ValueOf(pref.EnumNumber(n)), nil
+ return pref.ValueOfEnum(pref.EnumNumber(n)), nil
}
if name, ok := input.Name(); ok {
// Lookup EnumNumber based on name.
if enumVal := fd.Enum().Values().ByName(name); enumVal != nil {
- return pref.ValueOf(enumVal.Number()), nil
+ return pref.ValueOfEnum(enumVal.Number()), nil
}
}
default:
@@ -488,8 +488,8 @@
fdType := fds.ByNumber(fieldnum.Any_TypeUrl)
fdValue := fds.ByNumber(fieldnum.Any_Value)
- m.Set(fdType, pref.ValueOf(typeURL))
- m.Set(fdValue, pref.ValueOf(b))
+ m.Set(fdType, pref.ValueOfString(typeURL))
+ m.Set(fdValue, pref.ValueOfBytes(b))
return nil
}