all: rename Vector as List
The terminology Vector does not occur in protobuf documentation at all,
so we should rename the Go use of the term to something more recognizable.
As such, all instances that match the regexp "[Vv]ect(or)?" were replaced.
The C++ documentation uses the term "Repeated", which is a reasonable name.
However, the term became overloaded in 2014, when maps were added as a feature
and implementated under the hood as repeated fields. This is confusing as it
means "repeated" could either refer to repeated fields proper (i.e., explicitly
marked with the "repeated" label in the proto file) or map fields. In the case
of the C++ reflective API, this is not a problem since repeated fields proper
and map fields are interacted with through the same RepeatedField type.
In Go, we do not use a single type to handle both types of repeated fields:
1) We are coming up with the Go protobuf reflection API for the first time
and so do not need to piggy-back on the repeated fields API to remain backwards
compatible since no former usages of Go protobuf reflection exists.
2) Map fields are commonly represented in Go as the Go map type, which do not
preserve ordering information. As such it is fundamentally impossible to present
an unordered map as a consistently ordered list. Thus, Go needs two different
interfaces for lists and maps.
Given the above situation, "Repeated" is not a great term to use since it
refers to two different things (when we only want one of the meanings).
To distinguish between the two, we'll use the terms "List" and "Map" instead.
There is some precedence for the term "List" in the protobuf codebase
(e.g., "getRepeatedInt32List").
Change-Id: Iddcdb6b78e1e60c14fa4ca213c15f45e214b967b
Reviewed-on: https://go-review.googlesource.com/c/149657
Reviewed-by: Damien Neil <dneil@google.com>
diff --git a/internal/impl/legacy_extension.go b/internal/impl/legacy_extension.go
index cff89f7..ba3a614 100644
--- a/internal/impl/legacy_extension.go
+++ b/internal/impl/legacy_extension.go
@@ -47,7 +47,7 @@
}
t := legacyExtensionTypeOf(x.desc)
if t.Cardinality() == pref.Repeated {
- return legacyExtensionValueOf(x.val, t).Vector().Len() > 0
+ return legacyExtensionValueOf(x.val, t).List().Len() > 0
}
return true
}
@@ -60,7 +60,7 @@
t := legacyExtensionTypeOf(x.desc)
if x.val == nil {
if t.Cardinality() == pref.Repeated {
- // TODO: What is the zero value for Vectors?
+ // TODO: What is the zero value for Lists?
// TODO: This logic is racy.
v := t.ValueOf(t.New())
x.val = legacyExtensionInterfaceOf(v, t)
@@ -305,10 +305,10 @@
if reflect.TypeOf(v) != xt2.typ {
panic(fmt.Sprintf("invalid type: got %T, want %v", v, xt2.typ))
}
- return pref.ValueOf(pvalue.VectorOf(v, conv))
+ return pref.ValueOf(pvalue.ListOf(v, conv))
}
xt2.interfaceOf = func(pv pref.Value) interface{} {
- v := pv.Vector().(pvalue.Unwrapper).Unwrap()
+ v := pv.List().(pvalue.Unwrapper).Unwrap()
if reflect.TypeOf(v) != xt2.typ {
panic(fmt.Sprintf("invalid type: got %T, want %v", v, xt2.typ))
}
diff --git a/internal/impl/legacy_test.go b/internal/impl/legacy_test.go
index 9f8456e..7e95ec9 100644
--- a/internal/impl/legacy_test.go
+++ b/internal/impl/legacy_test.go
@@ -776,7 +776,7 @@
}
// Check that getting the zero value returns the default value for scalars,
- // nil for singular messages, and an empty vector for repeated fields.
+ // nil for singular messages, and an empty list for repeated fields.
defaultValues := []interface{}{
bool(true),
int32(-12345),
@@ -816,7 +816,7 @@
}
}
- // Set some values and append to values to the vectors.
+ // Set some values and append to values to the lists.
m1 := &proto2_20180125.Message_ChildMessage{F1: protoV1.String("m1")}
m2 := &proto2_20180125.Message_ChildMessage{F1: protoV1.String("m2")}
setValues := []interface{}{
@@ -842,7 +842,7 @@
}
for i, xt := range extensions[len(extensions)/2:] {
v := extensions[i].ValueOf(setValues[i])
- fs.Get(xt.Number()).Vector().Append(v)
+ fs.Get(xt.Number()).List().Append(v)
}
// Get the values and check for equality.
diff --git a/internal/impl/message.go b/internal/impl/message.go
index 57ca93a..4d96719 100644
--- a/internal/impl/message.go
+++ b/internal/impl/message.go
@@ -132,7 +132,7 @@
case fd.IsMap():
fi = fieldInfoForMap(fd, fs)
case fd.Cardinality() == pref.Repeated:
- fi = fieldInfoForVector(fd, fs)
+ fi = fieldInfoForList(fd, fs)
case fd.Kind() == pref.MessageKind || fd.Kind() == pref.GroupKind:
fi = fieldInfoForMessage(fd, fs)
default:
diff --git a/internal/impl/message_field.go b/internal/impl/message_field.go
index 7f8d49f..ea1c1eb 100644
--- a/internal/impl/message_field.go
+++ b/internal/impl/message_field.go
@@ -134,7 +134,7 @@
}
}
-func fieldInfoForVector(fd pref.FieldDescriptor, fs reflect.StructField) fieldInfo {
+func fieldInfoForList(fd pref.FieldDescriptor, fs reflect.StructField) fieldInfo {
ft := fs.Type
if ft.Kind() != reflect.Slice {
panic(fmt.Sprintf("invalid type: got %v, want slice kind", ft))
@@ -149,11 +149,11 @@
},
get: func(p pointer) pref.Value {
v := p.apply(fieldOffset).asType(fs.Type).Interface()
- return pref.ValueOf(pvalue.VectorOf(v, conv))
+ return pref.ValueOf(pvalue.ListOf(v, conv))
},
set: func(p pointer, v pref.Value) {
rv := p.apply(fieldOffset).asType(fs.Type).Elem()
- rv.Set(reflect.ValueOf(v.Vector().(pvalue.Unwrapper).Unwrap()).Elem())
+ rv.Set(reflect.ValueOf(v.List().(pvalue.Unwrapper).Unwrap()).Elem())
},
clear: func(p pointer) {
rv := p.apply(fieldOffset).asType(fs.Type).Elem()
@@ -161,7 +161,7 @@
},
mutable: func(p pointer) pref.Mutable {
v := p.apply(fieldOffset).asType(fs.Type).Interface()
- return pvalue.VectorOf(v, conv)
+ return pvalue.ListOf(v, conv)
},
}
}
diff --git a/internal/impl/message_test.go b/internal/impl/message_test.go
index 3f38671..69b5764 100644
--- a/internal/impl/message_test.go
+++ b/internal/impl/message_test.go
@@ -40,20 +40,20 @@
MyString string
MyBytes []byte
- VectorStrings []MyString
- VectorBytes []MyBytes
+ ListStrings []MyString
+ ListBytes []MyBytes
MapStrings map[MyString]MyString
MapBytes map[MyString]MyBytes
)
-// List of test operations to perform on messages, vectors, or maps.
+// List of test operations to perform on messages, lists, or maps.
type (
- messageOp interface{} // equalMessage | hasFields | getFields | setFields | clearFields | vectorFields | mapFields
+ messageOp interface{} // equalMessage | hasFields | getFields | setFields | clearFields | listFields | mapFields
messageOps []messageOp
- vectorOp interface{} // equalVector | lenVector | getVector | setVector | appendVector | truncVector
- vectorOps []vectorOp
+ listOp interface{} // equalList | lenList | getList | setList | appendList | truncList
+ listOps []listOp
mapOp interface{} // equalMap | lenMap | hasMap | getMap | setMap | clearMap | rangeMap
mapOps []mapOp
@@ -66,20 +66,20 @@
getFields map[pref.FieldNumber]pref.Value
setFields map[pref.FieldNumber]pref.Value
clearFields map[pref.FieldNumber]bool
- vectorFields map[pref.FieldNumber]vectorOps
+ listFields map[pref.FieldNumber]listOps
mapFields map[pref.FieldNumber]mapOps
messageFields map[pref.FieldNumber]messageOps
// TODO: Mutable, Range, ExtensionTypes
)
-// Test operations performed on a vector.
+// Test operations performed on a list.
type (
- equalVector pref.Vector
- lenVector int
- getVector map[int]pref.Value
- setVector map[int]pref.Value
- appendVector []pref.Value
- truncVector int
+ equalList pref.List
+ lenList int
+ getList map[int]pref.Value
+ setList map[int]pref.Value
+ appendList []pref.Value
+ truncList int
// TODO: Mutable, MutableAppend
)
@@ -318,10 +318,10 @@
MyBytes1 []MyBytes `protobuf:"14"`
MyBytes2 []MyString `protobuf:"15"`
- MyStrings3 VectorStrings `protobuf:"16"`
- MyStrings4 VectorBytes `protobuf:"17"`
- MyBytes3 VectorBytes `protobuf:"18"`
- MyBytes4 VectorStrings `protobuf:"19"`
+ MyStrings3 ListStrings `protobuf:"16"`
+ MyStrings4 ListBytes `protobuf:"17"`
+ MyBytes3 ListBytes `protobuf:"18"`
+ MyBytes4 ListStrings `protobuf:"19"`
}
var listScalarsType = MessageType{Type: ptype.GoMessage(
@@ -386,10 +386,10 @@
MyBytes1: []MyBytes{[]byte("14"), nil, []byte("fourteen")},
MyBytes2: []MyString{"15", "", "fifteen"},
- MyStrings3: VectorStrings{"16", "", "sixteen"},
- MyStrings4: VectorBytes{[]byte("17"), nil, []byte("seventeen")},
- MyBytes3: VectorBytes{[]byte("18"), nil, []byte("eighteen")},
- MyBytes4: VectorStrings{"19", "", "nineteen"},
+ MyStrings3: ListStrings{"16", "", "sixteen"},
+ MyStrings4: ListBytes{[]byte("17"), nil, []byte("seventeen")},
+ MyBytes3: ListBytes{[]byte("18"), nil, []byte("eighteen")},
+ MyBytes4: ListStrings{"19", "", "nineteen"},
}
wantFS := want.KnownFields()
@@ -397,53 +397,53 @@
hasFields{1: false, 2: false, 3: false, 4: false, 5: false, 6: false, 7: false, 8: false, 9: false, 10: false, 11: false, 12: false, 13: false, 14: false, 15: false, 16: false, 17: false, 18: false, 19: false},
getFields{1: emptyFS.Get(1), 3: emptyFS.Get(3), 5: emptyFS.Get(5), 7: emptyFS.Get(7), 9: emptyFS.Get(9), 11: emptyFS.Get(11), 13: emptyFS.Get(13), 15: emptyFS.Get(15), 17: emptyFS.Get(17), 19: emptyFS.Get(19)},
setFields{1: wantFS.Get(1), 3: wantFS.Get(3), 5: wantFS.Get(5), 7: wantFS.Get(7), 9: wantFS.Get(9), 11: wantFS.Get(11), 13: wantFS.Get(13), 15: wantFS.Get(15), 17: wantFS.Get(17), 19: wantFS.Get(19)},
- vectorFields{
+ listFields{
2: {
- lenVector(0),
- appendVector{V(int32(2)), V(int32(math.MinInt32)), V(int32(math.MaxInt32))},
- getVector{0: V(int32(2)), 1: V(int32(math.MinInt32)), 2: V(int32(math.MaxInt32))},
- equalVector(wantFS.Get(2).Vector()),
+ lenList(0),
+ appendList{V(int32(2)), V(int32(math.MinInt32)), V(int32(math.MaxInt32))},
+ getList{0: V(int32(2)), 1: V(int32(math.MinInt32)), 2: V(int32(math.MaxInt32))},
+ equalList(wantFS.Get(2).List()),
},
4: {
- appendVector{V(uint32(0)), V(uint32(0)), V(uint32(0))},
- setVector{0: V(uint32(4)), 1: V(uint32(math.MaxUint32 / 2)), 2: V(uint32(math.MaxUint32))},
- lenVector(3),
+ appendList{V(uint32(0)), V(uint32(0)), V(uint32(0))},
+ setList{0: V(uint32(4)), 1: V(uint32(math.MaxUint32 / 2)), 2: V(uint32(math.MaxUint32))},
+ lenList(3),
},
6: {
- appendVector{V(float32(6)), V(float32(math.SmallestNonzeroFloat32)), V(float32(math.NaN())), V(float32(math.MaxFloat32))},
- equalVector(wantFS.Get(6).Vector()),
+ appendList{V(float32(6)), V(float32(math.SmallestNonzeroFloat32)), V(float32(math.NaN())), V(float32(math.MaxFloat32))},
+ equalList(wantFS.Get(6).List()),
},
8: {
- appendVector{V(""), V(""), V(""), V(""), V(""), V("")},
- lenVector(6),
- setVector{0: V("8"), 2: V("eight")},
- truncVector(3),
- equalVector(wantFS.Get(8).Vector()),
+ appendList{V(""), V(""), V(""), V(""), V(""), V("")},
+ lenList(6),
+ setList{0: V("8"), 2: V("eight")},
+ truncList(3),
+ equalList(wantFS.Get(8).List()),
},
10: {
- appendVector{V([]byte(nil)), V([]byte(nil))},
- setVector{0: V([]byte("10"))},
- appendVector{V([]byte("wrong"))},
- setVector{2: V([]byte("ten"))},
- equalVector(wantFS.Get(10).Vector()),
+ appendList{V([]byte(nil)), V([]byte(nil))},
+ setList{0: V([]byte("10"))},
+ appendList{V([]byte("wrong"))},
+ setList{2: V([]byte("ten"))},
+ equalList(wantFS.Get(10).List()),
},
12: {
- appendVector{V("12"), V("wrong"), V("twelve")},
- setVector{1: V("")},
- equalVector(wantFS.Get(12).Vector()),
+ appendList{V("12"), V("wrong"), V("twelve")},
+ setList{1: V("")},
+ equalList(wantFS.Get(12).List()),
},
14: {
- appendVector{V([]byte("14")), V([]byte(nil)), V([]byte("fourteen"))},
- equalVector(wantFS.Get(14).Vector()),
+ appendList{V([]byte("14")), V([]byte(nil)), V([]byte("fourteen"))},
+ equalList(wantFS.Get(14).List()),
},
16: {
- appendVector{V("16"), V(""), V("sixteen"), V("extra")},
- truncVector(3),
- equalVector(wantFS.Get(16).Vector()),
+ appendList{V("16"), V(""), V("sixteen"), V("extra")},
+ truncList(3),
+ equalList(wantFS.Get(16).List()),
},
18: {
- appendVector{V([]byte("18")), V([]byte(nil)), V([]byte("eighteen"))},
- equalVector(wantFS.Get(18).Vector()),
+ appendList{V([]byte("18")), V([]byte(nil)), V([]byte("eighteen"))},
+ equalList(wantFS.Get(18).List()),
},
},
hasFields{1: true, 2: true, 3: true, 4: true, 5: true, 6: true, 7: true, 8: true, 9: true, 10: true, 11: true, 12: true, 13: true, 14: true, 15: true, 16: true, 17: true, 18: true, 19: true},
@@ -828,7 +828,7 @@
cmp.Transformer("UnwrapValue", func(v pref.Value) interface{} {
return v.Interface()
}),
- cmp.Transformer("UnwrapVector", func(v pref.Vector) interface{} {
+ cmp.Transformer("UnwrapList", func(v pref.List) interface{} {
return v.(interface{ Unwrap() interface{} }).Unwrap()
}),
cmp.Transformer("UnwrapMap", func(m pref.Map) interface{} {
@@ -874,10 +874,10 @@
fs.Clear(n)
}
}
- case vectorFields:
+ case listFields:
for n, tt := range op {
p.Push(int(n))
- testVectors(t, p, fs.Mutable(n).(pref.Vector), tt)
+ testLists(t, p, fs.Mutable(n).(pref.List), tt)
p.Pop()
}
case mapFields:
@@ -893,36 +893,36 @@
}
}
-func testVectors(t *testing.T, p path, v pref.Vector, tt vectorOps) {
+func testLists(t *testing.T, p path, v pref.List, tt listOps) {
for i, op := range tt {
p.Push(i)
switch op := op.(type) {
- case equalVector:
+ case equalList:
if diff := cmp.Diff(op, v, cmpOpts); diff != "" {
- t.Errorf("operation %v, vector mismatch (-want, +got):\n%s", p, diff)
+ t.Errorf("operation %v, list mismatch (-want, +got):\n%s", p, diff)
}
- case lenVector:
+ case lenList:
if got, want := v.Len(), int(op); got != want {
- t.Errorf("operation %v, Vector.Len = %d, want %d", p, got, want)
+ t.Errorf("operation %v, List.Len = %d, want %d", p, got, want)
}
- case getVector:
+ case getList:
got := map[int]pref.Value{}
want := map[int]pref.Value(op)
for n := range want {
got[n] = v.Get(n)
}
if diff := cmp.Diff(want, got, cmpOpts); diff != "" {
- t.Errorf("operation %v, Vector.Get mismatch (-want, +got):\n%s", p, diff)
+ t.Errorf("operation %v, List.Get mismatch (-want, +got):\n%s", p, diff)
}
- case setVector:
+ case setList:
for n, e := range op {
v.Set(n, e)
}
- case appendVector:
+ case appendList:
for _, e := range op {
v.Append(e)
}
- case truncVector:
+ case truncList:
v.Truncate(int(op))
default:
t.Fatalf("operation %v, invalid operation: %T", p, op)
diff --git a/internal/value/convert.go b/internal/value/convert.go
index ea29244..e491fd1 100644
--- a/internal/value/convert.go
+++ b/internal/value/convert.go
@@ -14,7 +14,7 @@
)
// Unwrapper unwraps the value to the underlying value.
-// This is implemented by Vector and Map.
+// This is implemented by List and Map.
type Unwrapper interface {
Unwrap() interface{}
}
diff --git a/internal/value/list.go b/internal/value/list.go
new file mode 100644
index 0000000..2eec007
--- /dev/null
+++ b/internal/value/list.go
@@ -0,0 +1,63 @@
+// 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.
+
+package value
+
+import (
+ "reflect"
+
+ pref "github.com/golang/protobuf/v2/reflect/protoreflect"
+)
+
+func ListOf(p interface{}, c Converter) pref.List {
+ // TODO: Validate that p is a *[]T?
+ rv := reflect.ValueOf(p).Elem()
+ return listReflect{rv, c}
+}
+
+type listReflect struct {
+ v reflect.Value // addressable []T
+ conv Converter
+}
+
+func (ls listReflect) Len() int {
+ return ls.v.Len()
+}
+func (ls listReflect) Get(i int) pref.Value {
+ return ls.conv.PBValueOf(ls.v.Index(i))
+}
+func (ls listReflect) Set(i int, v pref.Value) {
+ ls.v.Index(i).Set(ls.conv.GoValueOf(v))
+}
+func (ls listReflect) Append(v pref.Value) {
+ ls.v.Set(reflect.Append(ls.v, ls.conv.GoValueOf(v)))
+}
+func (ls listReflect) Mutable(i int) pref.Mutable {
+ // Mutable is only valid for messages and panics for other kinds.
+ rv := ls.v.Index(i)
+ if rv.IsNil() {
+ // TODO: Is checking for nil proper behavior for custom messages?
+ pv := pref.ValueOf(ls.conv.MessageType.New().ProtoReflect())
+ rv.Set(ls.conv.GoValueOf(pv))
+ }
+ return rv.Interface().(pref.Message)
+}
+func (ls listReflect) MutableAppend() pref.Mutable {
+ // MutableAppend is only valid for messages and panics for other kinds.
+ pv := pref.ValueOf(ls.conv.MessageType.New().ProtoReflect())
+ ls.v.Set(reflect.Append(ls.v, ls.conv.GoValueOf(pv)))
+ return ls.v.Index(ls.Len() - 1).Interface().(pref.Message)
+}
+func (ls listReflect) Truncate(i int) {
+ ls.v.Set(ls.v.Slice(0, i))
+}
+func (ls listReflect) Unwrap() interface{} {
+ return ls.v.Addr().Interface()
+}
+func (ls listReflect) ProtoMutable() {}
+
+var (
+ _ pref.List = listReflect{}
+ _ Unwrapper = listReflect{}
+)
diff --git a/internal/value/vector.go b/internal/value/vector.go
deleted file mode 100644
index d6efd99..0000000
--- a/internal/value/vector.go
+++ /dev/null
@@ -1,63 +0,0 @@
-// 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.
-
-package value
-
-import (
- "reflect"
-
- pref "github.com/golang/protobuf/v2/reflect/protoreflect"
-)
-
-func VectorOf(p interface{}, c Converter) pref.Vector {
- // TODO: Validate that p is a *[]T?
- rv := reflect.ValueOf(p).Elem()
- return vectorReflect{rv, c}
-}
-
-type vectorReflect struct {
- v reflect.Value // addressable []T
- conv Converter
-}
-
-func (vs vectorReflect) Len() int {
- return vs.v.Len()
-}
-func (vs vectorReflect) Get(i int) pref.Value {
- return vs.conv.PBValueOf(vs.v.Index(i))
-}
-func (vs vectorReflect) Set(i int, v pref.Value) {
- vs.v.Index(i).Set(vs.conv.GoValueOf(v))
-}
-func (vs vectorReflect) Append(v pref.Value) {
- vs.v.Set(reflect.Append(vs.v, vs.conv.GoValueOf(v)))
-}
-func (vs vectorReflect) Mutable(i int) pref.Mutable {
- // Mutable is only valid for messages and panics for other kinds.
- rv := vs.v.Index(i)
- if rv.IsNil() {
- // TODO: Is checking for nil proper behavior for custom messages?
- pv := pref.ValueOf(vs.conv.MessageType.New().ProtoReflect())
- rv.Set(vs.conv.GoValueOf(pv))
- }
- return rv.Interface().(pref.Message)
-}
-func (vs vectorReflect) MutableAppend() pref.Mutable {
- // MutableAppend is only valid for messages and panics for other kinds.
- pv := pref.ValueOf(vs.conv.MessageType.New().ProtoReflect())
- vs.v.Set(reflect.Append(vs.v, vs.conv.GoValueOf(pv)))
- return vs.v.Index(vs.Len() - 1).Interface().(pref.Message)
-}
-func (vs vectorReflect) Truncate(i int) {
- vs.v.Set(vs.v.Slice(0, i))
-}
-func (vs vectorReflect) Unwrap() interface{} {
- return vs.v.Addr().Interface()
-}
-func (vs vectorReflect) ProtoMutable() {}
-
-var (
- _ pref.Vector = vectorReflect{}
- _ Unwrapper = vectorReflect{}
-)
diff --git a/reflect/protoreflect/type.go b/reflect/protoreflect/type.go
index ceb763c..5a12921 100644
--- a/reflect/protoreflect/type.go
+++ b/reflect/protoreflect/type.go
@@ -305,7 +305,7 @@
IsPacked() bool
// IsMap reports whether this field represents a map.
- // The value type for the associated field is a Map instead of a Vector.
+ // The value type for the associated field is a Map instead of a List.
//
// If true, it implies that Kind is MessageKind, Cardinality is Repeated,
// and MessageDescriptor.IsMapEntry is true.
@@ -449,7 +449,7 @@
// TODO: What to do with nil?
// Should ValueOf(nil) return Value{}?
// Should InterfaceOf(Value{}) return nil?
- // Similarly, should the Value.{Message,Vector,Map} also return nil?
+ // Similarly, should the Value.{Message,List,Map} also return nil?
// ValueOf wraps the input and returns it as a Value.
// ValueOf panics if the input value is invalid or not the appropriate type.
diff --git a/reflect/protoreflect/value.go b/reflect/protoreflect/value.go
index 832f925..93ff1ff 100644
--- a/reflect/protoreflect/value.go
+++ b/reflect/protoreflect/value.go
@@ -42,8 +42,8 @@
// KnownFields provides accessor and mutator methods for known fields.
//
-// Each field Value can either be a scalar, Message, Vector, or Map.
-// The field is a Vector or Map if FieldDescriptor.Cardinality is Repeated and
+// Each field Value can either be a scalar, Message, List, or Map.
+// The field is a List or Map if FieldDescriptor.Cardinality is Repeated and
// a Map if and only if FieldDescriptor.IsMap is true. The scalar type or
// underlying repeated element type is determined by the FieldDescriptor.Kind.
// See Value for a list of Go types associated with each Kind.
@@ -94,7 +94,7 @@
// Mutable returns a reference value for a field with a given field number,
// allocating a new instance if necessary.
- // It panics if the field is not a map, vector, or message.
+ // It panics if the field is not a message, list, or map.
Mutable(FieldNumber) Mutable
// Range iterates over every populated field in an undefined order,
@@ -214,14 +214,14 @@
Range(f func(ExtensionType) bool)
}
-// Vector is an ordered list. Every element is considered populated
+// List is an ordered list. Every element is considered populated
// (i.e., Get never provides and Set never accepts invalid Values).
// The element Value type is determined by the associated FieldDescriptor.Kind
-// and cannot be a Map or Vector.
+// and cannot be a Map or List.
//
// Len and Get are safe for concurrent use.
-type Vector interface {
- // Len reports the number of entries in the Vector.
+type List interface {
+ // Len reports the number of entries in the List.
// Get, Set, Mutable, and Truncate panic with out of bound indexes.
Len() int
@@ -234,7 +234,7 @@
// value aliases the source's memory in any way.
Set(int, Value)
- // Append appends the provided value to the end of the vector.
+ // Append appends the provided value to the end of the list.
//
// When appending a composite type, it is unspecified whether the appended
// value aliases the source's memory in any way.
@@ -251,7 +251,7 @@
// TODO: Should truncate accept two indexes similar to slicing?M
- // Truncate truncates the vector to a smaller length.
+ // Truncate truncates the list to a smaller length.
Truncate(int)
// ProtoMutable is a marker method to implement the Mutable interface.
@@ -260,7 +260,7 @@
// Map is an unordered, associative map. Only elements within the map
// is considered populated. The entry Value type is determined by the associated
-// FieldDescripto.Kind and cannot be a Map or Vector.
+// FieldDescripto.Kind and cannot be a Map or List.
//
// Len, Has, Get, and Range are safe for concurrent use.
type Map interface {
@@ -303,7 +303,7 @@
}
// Mutable is a mutable reference, where mutate operations also affect
-// the backing store. Possible Mutable types: Vector, Map, or Message.
+// the backing store. Possible Mutable types: Message, List, or Map.
type Mutable interface {
ProtoMutable()
}
diff --git a/reflect/protoreflect/value_test.go b/reflect/protoreflect/value_test.go
index 2b56f4a..c6bbb58 100644
--- a/reflect/protoreflect/value_test.go
+++ b/reflect/protoreflect/value_test.go
@@ -13,7 +13,7 @@
func TestValue(t *testing.T) {
fakeMessage := new(struct{ Message })
- fakeVector := new(struct{ Vector })
+ fakeList := new(struct{ List })
fakeMap := new(struct{ Map })
tests := []struct {
@@ -32,7 +32,7 @@
{in: ValueOf(string("hello")), want: string("hello")},
{in: ValueOf([]byte("hello")), want: []byte("hello")},
{in: ValueOf(fakeMessage), want: fakeMessage},
- {in: ValueOf(fakeVector), want: fakeVector},
+ {in: ValueOf(fakeList), want: fakeList},
{in: ValueOf(fakeMap), want: fakeMap},
}
@@ -86,14 +86,14 @@
if got := tt.in.Message(); got != want {
t.Errorf("Value(%v).Message() = %v, want %v", tt.in, got, tt.want)
}
+ case List:
+ if got := tt.in.List(); got != want {
+ t.Errorf("Value(%v).List() = %v, want %v", tt.in, got, tt.want)
+ }
case Map:
if got := tt.in.Map(); got != want {
t.Errorf("Value(%v).Map() = %v, want %v", tt.in, got, tt.want)
}
- case Vector:
- if got := tt.in.Vector(); got != want {
- t.Errorf("Value(%v).Vector() = %v, want %v", tt.in, got, tt.want)
- }
}
}
}
diff --git a/reflect/protoreflect/value_union.go b/reflect/protoreflect/value_union.go
index aa47348..1fc3993 100644
--- a/reflect/protoreflect/value_union.go
+++ b/reflect/protoreflect/value_union.go
@@ -29,7 +29,7 @@
// | EnumNumber | EnumKind |
// +------------+-------------------------------------+
// | Message | MessageKind, GroupKind |
-// | Vector | |
+// | List | |
// | Map | |
// +------------+-------------------------------------+
//
@@ -38,7 +38,7 @@
// Int64Kind, Sint64Kind, and Sfixed64Kind are all represented by int64,
// but use different integer encoding methods.
//
-// The Vector or Map types are used if the FieldDescriptor.Cardinality of the
+// The List or Map types are used if the FieldDescriptor.Cardinality of the
// corresponding field is Repeated and a Map if and only if
// FieldDescriptor.IsMap is true.
//
@@ -93,7 +93,7 @@
return valueOfBytes(v[:len(v):len(v)])
case EnumNumber:
return Value{typ: enumType, num: uint64(v)}
- case Message, Vector, Map:
+ case Message, List, Map:
return valueOfIface(v)
default:
// TODO: Special case ProtoEnum, ProtoMessage, *[]T, and *map[K]V?
@@ -222,10 +222,10 @@
}
}
-// Vector returns v as a Vector and panics if the type is not a Vector.
-func (v Value) Vector() Vector {
+// List returns v as a List and panics if the type is not a List.
+func (v Value) List() List {
switch v := v.getIface().(type) {
- case Vector:
+ case List:
return v
default:
panic("proto: value type mismatch")
diff --git a/reflect/prototype/go_type.go b/reflect/prototype/go_type.go
index 00d440e..18bd8c3 100644
--- a/reflect/prototype/go_type.go
+++ b/reflect/prototype/go_type.go
@@ -86,7 +86,7 @@
// in which case it replaces the original message in ExtensionDescriptor.
//
// The Go type is currently determined automatically.
-// The type is T for scalars and *[]T for vectors (maps are not allowed).
+// The type is T for scalars and *[]T for lists (maps are not allowed).
// The type T is determined as follows:
//
// +------------+-------------------------------------+
@@ -244,13 +244,13 @@
return reflect.New(t.typ.Elem()).Interface()
}
t.valueOf = func(v interface{}) protoreflect.Value {
- return protoreflect.ValueOf(value.VectorOf(v, c))
+ return protoreflect.ValueOf(value.ListOf(v, c))
}
t.interfaceOf = func(pv protoreflect.Value) interface{} {
- // TODO: Can we assume that Vector implementations know how
+ // TODO: Can we assume that List implementations know how
// to unwrap themselves?
// Should this be part of the public API in protoreflect?
- return pv.Vector().(value.Unwrapper).Unwrap()
+ return pv.List().(value.Unwrapper).Unwrap()
}
default:
panic(fmt.Sprintf("invalid cardinality: %v", t.Cardinality()))
