mirror of
https://github.com/protocolbuffers/protobuf-go.git
synced 2025-01-01 11:58:21 +00:00
378c1329de
Added API: Message.Len Message.Range Message.Has Message.Clear Message.Get Message.Set Message.Mutable Message.NewMessage Message.WhichOneof Message.GetUnknown Message.SetUnknown Deprecated API (to be removed in subsequent CL): Message.KnownFields Message.UnknownFields The primary difference with the new API is that the top-level Message methods are keyed by FieldDescriptor rather than FieldNumber with the following semantics: * For known fields, the FieldDescriptor must exactly match the field descriptor known by the message. * For extension fields, the FieldDescriptor must implement ExtensionType, where ContainingMessage.FullName matches the message name, and the field number is within the message's extension range. When setting an extension field, it automatically stores the extension type information. * Extension fields are always considered nullable, implying that repeated extension fields are nullable. That is, you can distinguish between a unpopulated list and an empty list. * Message.Get always returns a valid Value even if unpopulated. The behavior is already well-defined for scalars, but for unpopulated composite types, it now returns an empty read-only version of it. Change-Id: Ia120630b4db221aeaaf743d0f64160e1a61a0f61 Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/175458 Reviewed-by: Damien Neil <dneil@google.com>
78 lines
2.2 KiB
Go
78 lines
2.2 KiB
Go
// Copyright 2019 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 proto
|
|
|
|
import (
|
|
"google.golang.org/protobuf/internal/encoding/wire"
|
|
"google.golang.org/protobuf/reflect/protoreflect"
|
|
)
|
|
|
|
// Size returns the size in bytes of the wire-format encoding of m.
|
|
func Size(m Message) int {
|
|
return MarshalOptions{}.Size(m)
|
|
}
|
|
|
|
// Size returns the size in bytes of the wire-format encoding of m.
|
|
func (o MarshalOptions) Size(m Message) int {
|
|
if size, err := sizeMessageFast(m); err == nil {
|
|
return size
|
|
}
|
|
return sizeMessage(m.ProtoReflect())
|
|
}
|
|
|
|
func sizeMessageFast(m Message) (int, error) {
|
|
// TODO: Pass MarshalOptions to size to permit disabling fast path?
|
|
methods := protoMethods(m)
|
|
if methods == nil || methods.Size == nil {
|
|
return 0, errInternalNoFast
|
|
}
|
|
return methods.Size(m), nil
|
|
}
|
|
|
|
func sizeMessage(m protoreflect.Message) (size int) {
|
|
m.Range(func(fd protoreflect.FieldDescriptor, v protoreflect.Value) bool {
|
|
size += sizeField(fd, v)
|
|
return true
|
|
})
|
|
size += len(m.GetUnknown())
|
|
return size
|
|
}
|
|
|
|
func sizeField(fd protoreflect.FieldDescriptor, value protoreflect.Value) (size int) {
|
|
num := fd.Number()
|
|
switch {
|
|
case fd.IsList():
|
|
return sizeList(num, fd, value.List())
|
|
case fd.IsMap():
|
|
return sizeMap(num, fd, value.Map())
|
|
default:
|
|
return wire.SizeTag(num) + sizeSingular(num, fd.Kind(), value)
|
|
}
|
|
}
|
|
|
|
func sizeList(num wire.Number, fd protoreflect.FieldDescriptor, list protoreflect.List) (size int) {
|
|
if fd.IsPacked() && list.Len() > 0 {
|
|
content := 0
|
|
for i, llen := 0, list.Len(); i < llen; i++ {
|
|
content += sizeSingular(num, fd.Kind(), list.Get(i))
|
|
}
|
|
return wire.SizeTag(num) + wire.SizeBytes(content)
|
|
}
|
|
|
|
for i, llen := 0, list.Len(); i < llen; i++ {
|
|
size += wire.SizeTag(num) + sizeSingular(num, fd.Kind(), list.Get(i))
|
|
}
|
|
return size
|
|
}
|
|
|
|
func sizeMap(num wire.Number, fd protoreflect.FieldDescriptor, mapv protoreflect.Map) (size int) {
|
|
mapv.Range(func(key protoreflect.MapKey, value protoreflect.Value) bool {
|
|
size += wire.SizeTag(num)
|
|
size += wire.SizeBytes(sizeField(fd.MapKey(), key.Value()) + sizeField(fd.MapValue(), value))
|
|
return true
|
|
})
|
|
return size
|
|
}
|