protobuf-go/runtime/protoiface/methods.go

72 lines
2.1 KiB
Go
Raw Normal View History

// 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 protoiface
import (
"google.golang.org/protobuf/internal/pragma"
"google.golang.org/protobuf/reflect/protoreflect"
"google.golang.org/protobuf/reflect/protoregistry"
)
// Methoder is an optional interface implemented by generated messages to
// provide fast-path implementations of various operations.
type Methoder interface {
XXX_Methods() *Methods // may return nil
}
// Methods is a set of optional fast-path implementations of various operations.
type Methods struct {
// Flags indicate support for optional features.
Flags MethodFlag
// MarshalAppend appends the wire-format encoding of m to b, returning the result.
// It does not perform required field checks.
MarshalAppend func(b []byte, m protoreflect.ProtoMessage, opts MarshalOptions) ([]byte, error)
// Size returns the size in bytes of the wire-format encoding of m.
Size func(m protoreflect.ProtoMessage) int
// Unmarshal parses the wire-format message in b and places the result in m.
// It does not reset m or perform required field checks.
Unmarshal func(b []byte, m protoreflect.ProtoMessage, opts UnmarshalOptions) error
// IsInitialized returns an error if any required fields in m are not set.
IsInitialized func(m protoreflect.ProtoMessage) error
pragma.NoUnkeyedLiterals
}
// MethodFlag indicates support for optional fast-path features.
type MethodFlag int64
const (
// MethodFlagDeterministicMarshal indicates support for deterministic marshaling.
MethodFlagDeterministicMarshal MethodFlag = 1 << iota
)
// MarshalOptions configure the marshaler.
//
// This type is identical to the one in package proto.
type MarshalOptions struct {
AllowPartial bool
Deterministic bool
proto: replace CachedSize fast-path method with UseCachedSize option Using an option instead of a separate method has several useful properties: It makes it explicit whether the fast-path AppendMarshal is expected to use cached sizes or not. It properly plumbs the decision to use cached sizes through the call stack. Consider the case where message A includes B includes C: If A and C support cached sizes but B does not, we would like to use the size cache in all messages which support it. Placing this decision in the options allows this to work properly with no additional effort. Placing this option in MarshalOptions permits users to request use of existing cached sizes. This is a two-edged sword: There are places where this ability can permit substantial efficiencies, but this is also an exceedingly sharp-edged API. I believe that on balance the benefits outweigh the risks, especially since the prerequisites for using cached sizes are intuitively obvious. (You must have called Size, and you must not have changed the message.) This CL adds a Size method to MarshalOptions, rather than adding a SizeOptions type. Future additions to MarshalOptions may affect the size of the encoded output (e.g., an option to skip encoding unknown fields) and using the same options for both Marshal and Size makes it easier to use a consistent configuration for each. Change-Id: I6adbb55b717dd03d39f067e1d0b7381945000976 Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/171119 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2019-04-08 01:18:31 +00:00
UseCachedSize bool
pragma.NoUnkeyedLiterals
}
// UnmarshalOptions configures the unmarshaler.
//
// This type is identical to the one in package proto.
type UnmarshalOptions struct {
AllowPartial bool
DiscardUnknown bool
proto, encoding/protojson, encoding/prototext: use Resolver interface Instead of accepting a concrete protoregistry.Types type, accept an interface that provides the necessary functionality to perform the serialization. The advantages of this approach: * There is no need for complex logic to allow a Parent or custom Resolver on the protoregistry.Types type. * Users can pass their own custom resolver implementations directly to the serialization functions. * This is a more principled approach to plumbing custom resolvers than the previous approach of overloading behavior on the concrete Types type. The disadvantages of this approach: * A pointer to a concrete type is 8B, while an interface is 16B. However, the expansion of the {Marshal,Unmarshal}Options structs should be a concern solved separately from how to plumb custom resolvers. * The resolver interfaces as defined today may be insufficient to provide functionality needed in the future if protobuf expands its feature set. For example, let's suppose the Any message permits directly representing a enum by name. This would require the ability to lookup an enum by name. To support that hypothetical need, we can document that the serializers type-assert the provided Resolver to a EnumTypeResolver and use that if possible. There is some loss of type safety with this approach, but provides a clear path forward. Change-Id: I81ca80e59335d36be6b43d57ec8e17abfdfa3bad Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/177044 Reviewed-by: Damien Neil <dneil@google.com>
2019-05-14 21:28:19 +00:00
Resolver interface {
protoregistry.ExtensionTypeResolver
}
pragma.NoUnkeyedLiterals
}