mirror of
https://github.com/protocolbuffers/protobuf-go.git
synced 2025-01-01 03:14:16 +00:00
1c28304cc5
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>
72 lines
2.1 KiB
Go
72 lines
2.1 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 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
|
|
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
|
|
Resolver interface {
|
|
protoregistry.ExtensionTypeResolver
|
|
}
|
|
|
|
pragma.NoUnkeyedLiterals
|
|
}
|