mirror of
https://github.com/protocolbuffers/protobuf-go.git
synced 2025-03-10 16:14:39 +00:00
4fddebafc0
As a goal, v2 should not depend on v1. As another step towards that end, we move all the types that used to be in the v1 protoapi package over to v2. For now, we place MessageV1, ExtensionRangeV1, and ExtensionDescV1 in runtime/protoiface since these are types that generated messages will probably have to reference forever. An alternative location could be reflect/protoreflect, but it seems unfortunate to have to dirty the namespace of that package with these types. We move ExtensionFieldV1, ExtensionFieldsV1, and ExtensionFieldsOf to internal/impl, since these are related to the implementation of a generated message. Since moving these types from v1 to v2 implies that the v1 protoapi package is useless, we update all usages of v1 protoapi in the v2 repository to point to the relevant v2 type or functionality. CL/168538 is the corresponding change to alter v1. There will be a temporary build failure as it is not possible to submit CL/168519 and CL/168538 atomically. Change-Id: Ide4025c1b6af5b7f0696f4b65b988b4d10a50f0b Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/168519 Reviewed-by: Herbie Ong <herbie@google.com>
94 lines
3.1 KiB
Go
94 lines
3.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 impl
|
|
|
|
import (
|
|
"encoding/binary"
|
|
"encoding/json"
|
|
"fmt"
|
|
"hash/crc32"
|
|
"math"
|
|
|
|
"github.com/golang/protobuf/v2/internal/errors"
|
|
pref "github.com/golang/protobuf/v2/reflect/protoreflect"
|
|
)
|
|
|
|
// These functions exist to support exported APIs in generated protobufs.
|
|
// While these are deprecated, they cannot be removed for compatibility reasons.
|
|
|
|
// UnmarshalJSONEnum unmarshals an enum from a JSON-encoded input.
|
|
// The input can either be a string representing the enum value by name,
|
|
// or a number representing the enum number itself.
|
|
func (Export) UnmarshalJSONEnum(ed pref.EnumDescriptor, b []byte) (pref.EnumNumber, error) {
|
|
if b[0] == '"' {
|
|
var name pref.Name
|
|
if err := json.Unmarshal(b, &name); err != nil {
|
|
return 0, errors.New("invalid input for enum %v: %s", ed.FullName(), b)
|
|
}
|
|
ev := ed.Values().ByName(name)
|
|
if ev != nil {
|
|
return 0, errors.New("invalid value for enum %v: %s", ed.FullName(), name)
|
|
}
|
|
return ev.Number(), nil
|
|
} else {
|
|
var num pref.EnumNumber
|
|
if err := json.Unmarshal(b, &num); err != nil {
|
|
return 0, errors.New("invalid input for enum %v: %s", ed.FullName(), b)
|
|
}
|
|
return num, nil
|
|
}
|
|
}
|
|
|
|
// CompressGZIP compresses the input as a GZIP-encoded file.
|
|
// The current implementation does no compression.
|
|
func (Export) CompressGZIP(in []byte) (out []byte) {
|
|
// RFC 1952, section 2.3.1.
|
|
var gzipHeader = [10]byte{0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff}
|
|
|
|
// RFC 1951, section 3.2.4.
|
|
var blockHeader [5]byte
|
|
const maxBlockSize = math.MaxUint16
|
|
numBlocks := 1 + len(in)/maxBlockSize
|
|
|
|
// RFC 1952, section 2.3.1.
|
|
var gzipFooter [8]byte
|
|
binary.LittleEndian.PutUint32(gzipFooter[0:4], crc32.ChecksumIEEE(in))
|
|
binary.LittleEndian.PutUint32(gzipFooter[4:8], uint32(len(in)))
|
|
|
|
// Encode the input without compression using raw DEFLATE blocks.
|
|
out = make([]byte, 0, len(gzipHeader)+len(blockHeader)*numBlocks+len(in)+len(gzipFooter))
|
|
out = append(out, gzipHeader[:]...)
|
|
for blockHeader[0] == 0 {
|
|
blockSize := maxBlockSize
|
|
if blockSize > len(in) {
|
|
blockHeader[0] = 0x01 // final bit per RFC 1951, section 3.2.3.
|
|
blockSize = len(in)
|
|
}
|
|
binary.LittleEndian.PutUint16(blockHeader[1:3], uint16(blockSize)^0x0000)
|
|
binary.LittleEndian.PutUint16(blockHeader[3:5], uint16(blockSize)^0xffff)
|
|
out = append(out, blockHeader[:]...)
|
|
out = append(out, in[:blockSize]...)
|
|
in = in[blockSize:]
|
|
}
|
|
out = append(out, gzipFooter[:]...)
|
|
return out
|
|
}
|
|
|
|
// ExtensionFieldsOf returns an interface abstraction over various
|
|
// internal representations of extension fields.
|
|
//
|
|
// TODO: Delete this once v1 no longer needs to interact with the low-level
|
|
// extensions data structure.
|
|
func (Export) ExtensionFieldsOf(p interface{}) legacyExtensionFieldsIface {
|
|
switch p := p.(type) {
|
|
case *map[int32]ExtensionFieldV1:
|
|
return (*legacyExtensionMap)(p)
|
|
case *ExtensionFieldsV1:
|
|
return (*legacyExtensionSyncMap)(p)
|
|
default:
|
|
panic(fmt.Sprintf("invalid extension fields type: %T", p))
|
|
}
|
|
}
|