AuroraMiddleware/protobuf
1
0
Fork 0
Code Issues 1 Pull Requests Projects Releases Wiki Activity

Down integrate to GitHub

Browse Source
This commit is contained in:
Rafi Kamal 2019-08-22 16:14:22 -07:00
parent 893a7d31e1
commit 4f02f056b5
159 changed files with 5335 additions and 7888 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

336
conformance/binary_json_conformance_suite.cc
View File

@ -157,16 +157,16 @@ enum class Packed {
FALSE = 2,
};
const FieldDescriptor* GetFieldForType(
FieldDescriptor::Type type, bool repeated, bool is_proto3,
Packed packed = Packed::UNSPECIFIED) {
const FieldDescriptor* GetFieldForType(FieldDescriptor::Type type,
bool repeated, bool is_proto3,
Packed packed = Packed::UNSPECIFIED) {
const Descriptor* d = is_proto3 ?
TestAllTypesProto3().GetDescriptor() : TestAllTypesProto2().GetDescriptor();
for (int i = 0; i < d->field_count(); i++) {
const FieldDescriptor* f = d->field(i);
if (f->type() == type && f->is_repeated() == repeated) {
if (packed == Packed::TRUE && !f->is_packed() ||
packed == Packed::FALSE && f->is_packed()) {
if ((packed == Packed::TRUE && !f->is_packed()) ||
(packed == Packed::FALSE && f->is_packed())) {
continue;
}
return f;
@ -183,10 +183,8 @@ const FieldDescriptor* GetFieldForType(
packed_string = "Unpacked ";
}
GOOGLE_LOG(FATAL) << "Couldn't find field with type: "
<< repeated_string.c_str()
<< packed_string.c_str()
<< FieldDescriptor::TypeName(type)
<< " for "
<< repeated_string.c_str() << packed_string.c_str()
<< FieldDescriptor::TypeName(type) << " for "
<< proto_string.c_str();
return nullptr;
}
@ -396,14 +394,13 @@ void BinaryAndJsonConformanceSuite::RunValidProtobufTest(
void BinaryAndJsonConformanceSuite::RunValidBinaryProtobufTest(
const string& test_name, ConformanceLevel level,
const string& input_protobuf, bool is_proto3) {
RunValidBinaryProtobufTest(
test_name, level, input_protobuf, input_protobuf, is_proto3);
RunValidBinaryProtobufTest(test_name, level, input_protobuf, input_protobuf,
is_proto3);
}
void BinaryAndJsonConformanceSuite::RunValidBinaryProtobufTest(
const string& test_name, ConformanceLevel level,
const string& input_protobuf,
const string& expected_protobuf,
const string& input_protobuf, const string& expected_protobuf,
bool is_proto3) {
std::unique_ptr<Message> prototype = NewTestMessage(is_proto3);
ConformanceRequestSetting setting(
@ -625,8 +622,7 @@ void BinaryAndJsonConformanceSuite::TestValidDataForType(
// Test singular data for singular fields.
for (size_t i = 0; i < values.size(); i++) {
string proto =
cat(tag(field->number(), wire_type), values[i].first);
string proto = cat(tag(field->number(), wire_type), values[i].first);
string expected_proto =
cat(tag(field->number(), wire_type), values[i].second);
std::unique_ptr<Message> test_message = NewTestMessage(is_proto3);
@ -690,18 +686,15 @@ void BinaryAndJsonConformanceSuite::TestValidDataForType(
unpacked_proto_expected +=
cat(tag(unpacked_field->number(), wire_type), values[i].second);
}
default_proto_packed =
cat(tag(rep_field->number(),
WireFormatLite::WIRETYPE_LENGTH_DELIMITED),
delim(default_proto_packed));
default_proto_packed_expected =
cat(tag(rep_field->number(),
WireFormatLite::WIRETYPE_LENGTH_DELIMITED),
delim(default_proto_packed_expected));
packed_proto_packed =
cat(tag(packed_field->number(),
WireFormatLite::WIRETYPE_LENGTH_DELIMITED),
delim(packed_proto_packed));
default_proto_packed = cat(
tag(rep_field->number(), WireFormatLite::WIRETYPE_LENGTH_DELIMITED),
delim(default_proto_packed));
default_proto_packed_expected = cat(
tag(rep_field->number(), WireFormatLite::WIRETYPE_LENGTH_DELIMITED),
delim(default_proto_packed_expected));
packed_proto_packed = cat(tag(packed_field->number(),
WireFormatLite::WIRETYPE_LENGTH_DELIMITED),
delim(packed_proto_packed));
packed_proto_expected =
cat(tag(packed_field->number(),
WireFormatLite::WIRETYPE_LENGTH_DELIMITED),
@ -711,60 +704,44 @@ void BinaryAndJsonConformanceSuite::TestValidDataForType(
WireFormatLite::WIRETYPE_LENGTH_DELIMITED),
delim(unpacked_proto_packed));
std::unique_ptr<Message> test_message = NewTestMessage(is_proto3);
test_message->MergeFromString(default_proto_packed_expected);
string text = test_message->DebugString();
// Ensures both packed and unpacked data can be parsed.
RunValidProtobufTest(
StrCat("ValidDataRepeated", type_name, ".UnpackedInput"),
REQUIRED, default_proto_unpacked, text, is_proto3);
StrCat("ValidDataRepeated", type_name, ".UnpackedInput"), REQUIRED,
default_proto_unpacked, text, is_proto3);
RunValidProtobufTest(
StrCat("ValidDataRepeated", type_name, ".PackedInput"),
REQUIRED, default_proto_packed, text, is_proto3);
StrCat("ValidDataRepeated", type_name, ".PackedInput"), REQUIRED,
default_proto_packed, text, is_proto3);
// proto2 should encode as unpacked by default and proto3 should encode as
// packed by default.
string expected_proto =
rep_field->is_packed() ? default_proto_packed_expected :
default_proto_unpacked_expected;
string expected_proto = rep_field->is_packed()
? default_proto_packed_expected
: default_proto_unpacked_expected;
RunValidBinaryProtobufTest(StrCat("ValidDataRepeated", type_name,
".UnpackedInput.DefaultOutput"),
RECOMMENDED, default_proto_unpacked,
expected_proto, is_proto3);
RunValidBinaryProtobufTest(
StrCat("ValidDataRepeated", type_name,
".UnpackedInput.DefaultOutput"),
RECOMMENDED,
default_proto_unpacked,
expected_proto, is_proto3);
StrCat("ValidDataRepeated", type_name, ".PackedInput.DefaultOutput"),
RECOMMENDED, default_proto_packed, expected_proto, is_proto3);
RunValidBinaryProtobufTest(
StrCat("ValidDataRepeated", type_name,
".PackedInput.DefaultOutput"),
RECOMMENDED,
default_proto_packed,
expected_proto, is_proto3);
StrCat("ValidDataRepeated", type_name, ".UnpackedInput.PackedOutput"),
RECOMMENDED, packed_proto_unpacked, packed_proto_expected, is_proto3);
RunValidBinaryProtobufTest(
StrCat("ValidDataRepeated", type_name,
".UnpackedInput.PackedOutput"),
RECOMMENDED,
packed_proto_unpacked,
packed_proto_expected, is_proto3);
StrCat("ValidDataRepeated", type_name, ".PackedInput.PackedOutput"),
RECOMMENDED, packed_proto_packed, packed_proto_expected, is_proto3);
RunValidBinaryProtobufTest(StrCat("ValidDataRepeated", type_name,
".UnpackedInput.UnpackedOutput"),
RECOMMENDED, unpacked_proto_unpacked,
unpacked_proto_expected, is_proto3);
RunValidBinaryProtobufTest(
StrCat("ValidDataRepeated", type_name,
".PackedInput.PackedOutput"),
RECOMMENDED,
packed_proto_packed,
packed_proto_expected, is_proto3);
RunValidBinaryProtobufTest(
StrCat("ValidDataRepeated", type_name,
".UnpackedInput.UnpackedOutput"),
RECOMMENDED,
unpacked_proto_unpacked,
unpacked_proto_expected, is_proto3);
RunValidBinaryProtobufTest(
StrCat("ValidDataRepeated", type_name,
".PackedInput.UnpackedOutput"),
RECOMMENDED,
unpacked_proto_packed,
unpacked_proto_expected, is_proto3);
StrCat("ValidDataRepeated", type_name, ".PackedInput.UnpackedOutput"),
RECOMMENDED, unpacked_proto_packed, unpacked_proto_expected,
is_proto3);
} else {
string proto;
string expected_proto;
@ -777,27 +754,24 @@ void BinaryAndJsonConformanceSuite::TestValidDataForType(
test_message->MergeFromString(expected_proto);
string text = test_message->DebugString();
RunValidProtobufTest(
StrCat("ValidDataRepeated", type_name),
REQUIRED, proto, text, is_proto3);
RunValidProtobufTest(StrCat("ValidDataRepeated", type_name), REQUIRED,
proto, text, is_proto3);
}
}
}
void BinaryAndJsonConformanceSuite::TestValidDataForRepeatedScalarMessage() {
std::vector<std::string> values = {
delim(cat(tag(2, WireFormatLite::WIRETYPE_LENGTH_DELIMITED),
delim(cat(
tag(1, WireFormatLite::WIRETYPE_VARINT), varint(1234),
delim(cat(
tag(2, WireFormatLite::WIRETYPE_LENGTH_DELIMITED),
delim(cat(tag(1, WireFormatLite::WIRETYPE_VARINT), varint(1234),
tag(2, WireFormatLite::WIRETYPE_VARINT), varint(1234),
tag(31, WireFormatLite::WIRETYPE_VARINT), varint(1234)
)))),
delim(cat(tag(2, WireFormatLite::WIRETYPE_LENGTH_DELIMITED),
delim(cat(
tag(1, WireFormatLite::WIRETYPE_VARINT), varint(4321),
tag(31, WireFormatLite::WIRETYPE_VARINT), varint(1234))))),
delim(cat(
tag(2, WireFormatLite::WIRETYPE_LENGTH_DELIMITED),
delim(cat(tag(1, WireFormatLite::WIRETYPE_VARINT), varint(4321),
tag(3, WireFormatLite::WIRETYPE_VARINT), varint(4321),
tag(31, WireFormatLite::WIRETYPE_VARINT), varint(4321)
)))),
tag(31, WireFormatLite::WIRETYPE_VARINT), varint(4321))))),
};
const std::string expected =
@ -820,9 +794,8 @@ void BinaryAndJsonConformanceSuite::TestValidDataForRepeatedScalarMessage() {
values[i]);
}
RunValidProtobufTest(
"RepeatedScalarMessageMerge", REQUIRED, proto,
field->name() + ": " + expected, is_proto3);
RunValidProtobufTest("RepeatedScalarMessageMerge", REQUIRED, proto,
field->name() + ": " + expected, is_proto3);
}
}
@ -920,107 +893,106 @@ void BinaryAndJsonConformanceSuite::RunSuiteImpl() {
int32 kInt32Min = -2147483648;
uint32 kUint32Max = 4294967295UL;
TestValidDataForType(FieldDescriptor::TYPE_DOUBLE, {
{dbl(0.1), dbl(0.1)},
{dbl(1.7976931348623157e+308), dbl(1.7976931348623157e+308)},
{dbl(2.22507385850720138309e-308), dbl(2.22507385850720138309e-308)}
});
TestValidDataForType(FieldDescriptor::TYPE_FLOAT, {
{flt(0.1), flt(0.1)},
{flt(1.00000075e-36), flt(1.00000075e-36)},
{flt(3.402823e+38), flt(3.402823e+38)}, // 3.40282347e+38
{flt(1.17549435e-38f), flt(1.17549435e-38)}
});
TestValidDataForType(FieldDescriptor::TYPE_INT64, {
{varint(12345), varint(12345)},
{varint(kInt64Max), varint(kInt64Max)},
{varint(kInt64Min), varint(kInt64Min)}
});
TestValidDataForType(FieldDescriptor::TYPE_UINT64, {
{varint(12345), varint(12345)},
{varint(kUint64Max), varint(kUint64Max)},
{varint(0), varint(0)}
});
TestValidDataForType(FieldDescriptor::TYPE_INT32, {
{varint(12345), varint(12345)},
{longvarint(12345, 2), varint(12345)},
{longvarint(12345, 7), varint(12345)},
{varint(kInt32Max), varint(kInt32Max)},
{varint(kInt32Min), varint(kInt32Min)},
{varint(1LL << 33), varint(0)},
{varint((1LL << 33) - 1), varint(-1)},
});
TestValidDataForType(FieldDescriptor::TYPE_UINT32, {
{varint(12345), varint(12345)},
{longvarint(12345, 2), varint(12345)},
{longvarint(12345, 7), varint(12345)},
{varint(kUint32Max), varint(kUint32Max)}, // UINT32_MAX
{varint(0), varint(0)},
{varint(1LL << 33), varint(0)},
{varint((1LL << 33) - 1), varint((1LL << 32) - 1)},
});
TestValidDataForType(FieldDescriptor::TYPE_FIXED64, {
{u64(12345), u64(12345)},
{u64(kUint64Max), u64(kUint64Max)},
{u64(0), u64(0)}
});
TestValidDataForType(FieldDescriptor::TYPE_FIXED32, {
{u32(12345), u32(12345)},
{u32(kUint32Max), u32(kUint32Max)}, // UINT32_MAX
{u32(0), u32(0)}
});
TestValidDataForType(FieldDescriptor::TYPE_SFIXED64, {
{u64(12345), u64(12345)},
{u64(kInt64Max), u64(kInt64Max)},
{u64(kInt64Min), u64(kInt64Min)}
});
TestValidDataForType(FieldDescriptor::TYPE_SFIXED32, {
{u32(12345), u32(12345)},
{u32(kInt32Max), u32(kInt32Max)},
{u32(kInt32Min), u32(kInt32Min)}
});
TestValidDataForType(FieldDescriptor::TYPE_BOOL, {
{varint(1), varint(1)},
{varint(0), varint(0)},
{varint(12345678), varint(1)}
});
TestValidDataForType(FieldDescriptor::TYPE_SINT32, {
{zz32(12345), zz32(12345)},
{zz32(kInt32Max), zz32(kInt32Max)},
{zz32(kInt32Min), zz32(kInt32Min)}
});
TestValidDataForType(FieldDescriptor::TYPE_SINT64, {
{zz64(12345), zz64(12345)},
{zz64(kInt64Max), zz64(kInt64Max)},
{zz64(kInt64Min), zz64(kInt64Min)}
});
TestValidDataForType(FieldDescriptor::TYPE_STRING, {
{delim("Hello world!"), delim("Hello world!")},
{delim("\'\"\?\\\a\b\f\n\r\t\v"),
delim("\'\"\?\\\a\b\f\n\r\t\v")}, // escape
{delim("谷歌"), delim("谷歌")}, // Google in Chinese
{delim("\u8C37\u6B4C"), delim("谷歌")}, // unicode escape
{delim("\u8c37\u6b4c"), delim("谷歌")}, // lowercase unicode
{delim("\xF0\x9F\x98\x81"), delim("\xF0\x9F\x98\x81")}, // emoji: 😁
{delim(""), delim("")},
});
TestValidDataForType(FieldDescriptor::TYPE_BYTES, {
{delim("\x01\x02"), delim("\x01\x02")},
{delim("\xfb"), delim("\xfb")},
{delim(""), delim("")},
});
TestValidDataForType(
FieldDescriptor::TYPE_DOUBLE,
{{dbl(0.1), dbl(0.1)},
{dbl(1.7976931348623157e+308), dbl(1.7976931348623157e+308)},
{dbl(2.22507385850720138309e-308), dbl(2.22507385850720138309e-308)}});
TestValidDataForType(
FieldDescriptor::TYPE_FLOAT,
{{flt(0.1), flt(0.1)},
{flt(1.00000075e-36), flt(1.00000075e-36)},
{flt(3.402823e+38), flt(3.402823e+38)}, // 3.40282347e+38
{flt(1.17549435e-38f), flt(1.17549435e-38)}});
TestValidDataForType(FieldDescriptor::TYPE_INT64,
{{varint(12345), varint(12345)},
{varint(kInt64Max), varint(kInt64Max)},
{varint(kInt64Min), varint(kInt64Min)}});
TestValidDataForType(FieldDescriptor::TYPE_UINT64,
{{varint(12345), varint(12345)},
{varint(kUint64Max), varint(kUint64Max)},
{varint(0), varint(0)}});
TestValidDataForType(FieldDescriptor::TYPE_INT32,
{
{varint(12345), varint(12345)},
{longvarint(12345, 2), varint(12345)},
{longvarint(12345, 7), varint(12345)},
{varint(kInt32Max), varint(kInt32Max)},
{varint(kInt32Min), varint(kInt32Min)},
{varint(1LL << 33), varint(0)},
{varint((1LL << 33) - 1), varint(-1)},
});
TestValidDataForType(
FieldDescriptor::TYPE_UINT32,
{
{varint(12345), varint(12345)},
{longvarint(12345, 2), varint(12345)},
{longvarint(12345, 7), varint(12345)},
{varint(kUint32Max), varint(kUint32Max)}, // UINT32_MAX
{varint(0), varint(0)},
{varint(1LL << 33), varint(0)},
{varint((1LL << 33) - 1), varint((1LL << 32) - 1)},
});
TestValidDataForType(FieldDescriptor::TYPE_FIXED64,
{{u64(12345), u64(12345)},
{u64(kUint64Max), u64(kUint64Max)},
{u64(0), u64(0)}});
TestValidDataForType(FieldDescriptor::TYPE_FIXED32,
{{u32(12345), u32(12345)},
{u32(kUint32Max), u32(kUint32Max)}, // UINT32_MAX
{u32(0), u32(0)}});
TestValidDataForType(FieldDescriptor::TYPE_SFIXED64,
{{u64(12345), u64(12345)},
{u64(kInt64Max), u64(kInt64Max)},
{u64(kInt64Min), u64(kInt64Min)}});
TestValidDataForType(FieldDescriptor::TYPE_SFIXED32,
{{u32(12345), u32(12345)},
{u32(kInt32Max), u32(kInt32Max)},
{u32(kInt32Min), u32(kInt32Min)}});
TestValidDataForType(FieldDescriptor::TYPE_BOOL,
{{varint(1), varint(1)},
{varint(0), varint(0)},
{varint(12345678), varint(1)}});
TestValidDataForType(FieldDescriptor::TYPE_SINT32,
{{zz32(12345), zz32(12345)},
{zz32(kInt32Max), zz32(kInt32Max)},
{zz32(kInt32Min), zz32(kInt32Min)}});
TestValidDataForType(FieldDescriptor::TYPE_SINT64,
{{zz64(12345), zz64(12345)},
{zz64(kInt64Max), zz64(kInt64Max)},
{zz64(kInt64Min), zz64(kInt64Min)}});
TestValidDataForType(
FieldDescriptor::TYPE_STRING,
{
{delim("Hello world!"), delim("Hello world!")},
{delim("\'\"\?\\\a\b\f\n\r\t\v"),
delim("\'\"\?\\\a\b\f\n\r\t\v")}, // escape
{delim("谷歌"), delim("谷歌")}, // Google in Chinese
{delim("\u8C37\u6B4C"), delim("谷歌")}, // unicode escape
{delim("\u8c37\u6b4c"), delim("谷歌")}, // lowercase unicode
{delim("\xF0\x9F\x98\x81"), delim("\xF0\x9F\x98\x81")}, // emoji: 😁
{delim(""), delim("")},
});
TestValidDataForType(FieldDescriptor::TYPE_BYTES,
{
{delim("\x01\x02"), delim("\x01\x02")},
{delim("\xfb"), delim("\xfb")},
{delim(""), delim("")},
});
TestValidDataForType(FieldDescriptor::TYPE_ENUM, {
{varint(0), varint(0)},
{varint(1), varint(1)},
{varint(2), varint(2)},
{varint(-1), varint(-1)},
});
{varint(0), varint(0)},
{varint(1), varint(1)},
{varint(2), varint(2)},
{varint(-1), varint(-1)},
});
TestValidDataForRepeatedScalarMessage();
TestValidDataForType(FieldDescriptor::TYPE_MESSAGE, {
{delim(cat(tag(1, WireFormatLite::WIRETYPE_VARINT), varint(1234))),
delim(cat(tag(1, WireFormatLite::WIRETYPE_VARINT), varint(1234)))},
{delim(""), delim("")},
});
TestValidDataForType(
FieldDescriptor::TYPE_MESSAGE,
{
{delim(cat(tag(1, WireFormatLite::WIRETYPE_VARINT), varint(1234))),
delim(cat(tag(1, WireFormatLite::WIRETYPE_VARINT), varint(1234)))},
{delim(""), delim("")},
});
// TODO(haberman):
// TestValidDataForType(FieldDescriptor::TYPE_GROUP

26
conformance/conformance_cpp.cc
View File

@ -60,32 +60,6 @@ using std::string;
static const char kTypeUrlPrefix[] = "type.googleapis.com";
const char* kFailures[] = {
#if !GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
"Required.Proto2.ProtobufInput."
"PrematureEofInDelimitedDataForKnownNonRepeatedValue.MESSAGE",
"Required.Proto2.ProtobufInput."
"PrematureEofInDelimitedDataForKnownRepeatedValue.MESSAGE",
"Required.Proto2.ProtobufInput.PrematureEofInPackedField.BOOL",
"Required.Proto2.ProtobufInput.PrematureEofInPackedField.ENUM",
"Required.Proto2.ProtobufInput.PrematureEofInPackedField.INT32",
"Required.Proto2.ProtobufInput.PrematureEofInPackedField.INT64",
"Required.Proto2.ProtobufInput.PrematureEofInPackedField.SINT32",
"Required.Proto2.ProtobufInput.PrematureEofInPackedField.SINT64",
"Required.Proto2.ProtobufInput.PrematureEofInPackedField.UINT32",
"Required.Proto2.ProtobufInput.PrematureEofInPackedField.UINT64",
"Required.Proto3.ProtobufInput."
"PrematureEofInDelimitedDataForKnownNonRepeatedValue.MESSAGE",
"Required.Proto3.ProtobufInput."
"PrematureEofInDelimitedDataForKnownRepeatedValue.MESSAGE",
"Required.Proto3.ProtobufInput.PrematureEofInPackedField.BOOL",
"Required.Proto3.ProtobufInput.PrematureEofInPackedField.ENUM",
"Required.Proto3.ProtobufInput.PrematureEofInPackedField.INT32",
"Required.Proto3.ProtobufInput.PrematureEofInPackedField.INT64",
"Required.Proto3.ProtobufInput.PrematureEofInPackedField.SINT32",
"Required.Proto3.ProtobufInput.PrematureEofInPackedField.SINT64",
"Required.Proto3.ProtobufInput.PrematureEofInPackedField.UINT32",
"Required.Proto3.ProtobufInput.PrematureEofInPackedField.UINT64",
#endif
};
static string GetTypeUrl(const Descriptor* message) {

4
conformance/conformance_objc.m
View File

@ -80,8 +80,8 @@ static ConformanceResponse *DoTest(ConformanceRequest *request) {
msgClass = [TestAllTypesProto2 class];
} else {
response.runtimeError =
[NSString stringWithFormat:
@"Protobuf request had an unknown message_type: %@", request.messageType];
[NSString stringWithFormat:@"Protobuf request had an unknown message_type: %@",
request.messageType];
break;
}
NSError *error = nil;

19
conformance/conformance_test.cc
View File

@ -71,7 +71,7 @@ static string ToOctString(const string& binary_string) {
return oct_string;
}
}
} // namespace
namespace google {
namespace protobuf {
@ -239,21 +239,18 @@ void ConformanceTestSuite::RunValidInputTest(
void ConformanceTestSuite::RunValidBinaryInputTest(
const ConformanceRequestSetting& setting,
const string& equivalent_wire_format,
bool require_same_wire_format) {
const string& equivalent_wire_format, bool require_same_wire_format) {
const ConformanceRequest& request = setting.GetRequest();
ConformanceResponse response;
RunTest(setting.GetTestName(), request, &response);
VerifyResponse(setting, equivalent_wire_format, response,
true, require_same_wire_format);
VerifyResponse(setting, equivalent_wire_format, response, true,
require_same_wire_format);
}
void ConformanceTestSuite::VerifyResponse(
const ConformanceRequestSetting& setting,
const string& equivalent_wire_format,
const ConformanceResponse& response,
bool need_report_success,
bool require_same_wire_format) {
const string& equivalent_wire_format, const ConformanceResponse& response,
bool need_report_success, bool require_same_wire_format) {
Message* test_message = setting.GetTestMessage();
const ConformanceRequest& request = setting.GetRequest();
const string& test_name = setting.GetTestName();
@ -296,8 +293,8 @@ void ConformanceTestSuite::VerifyResponse(
if (require_same_wire_format) {
GOOGLE_DCHECK_EQ(response.result_case(),
ConformanceResponse::kProtobufPayload);
const string& protobuf_payload = response.protobuf_payload();
ConformanceResponse::kProtobufPayload);
const string& protobuf_payload = response.protobuf_payload();
check = equivalent_wire_format == protobuf_payload;
differences = StrCat("Expect: ", ToOctString(equivalent_wire_format),
", but got: ", ToOctString(protobuf_payload));

26
conformance/conformance_test.h
View File

@ -38,14 +38,15 @@
#ifndef CONFORMANCE_CONFORMANCE_TEST_H
#define CONFORMANCE_CONFORMANCE_TEST_H
#include <functional>
#include <string>
#include <google/protobuf/descriptor.h>
#include <google/protobuf/stubs/common.h>
#include <google/protobuf/util/type_resolver.h>
#include <google/protobuf/wire_format_lite.h>
#include <functional>
#include <string>
#include <vector>
#include "conformance.pb.h"
namespace conformance {
@ -88,7 +89,13 @@ class ForkPipeRunner : public ConformanceTestRunner {
static int Run(int argc, char *argv[],
const std::vector<ConformanceTestSuite*>& suites);
ForkPipeRunner(const std::string &executable)
ForkPipeRunner(const std::string& executable,
const std::vector<string>& executable_args)
: child_pid_(-1),
executable_(executable),
executable_args_(executable_args) {}
explicit ForkPipeRunner(const std::string& executable)
: child_pid_(-1), executable_(executable) {}
virtual ~ForkPipeRunner() {}
@ -108,6 +115,7 @@ class ForkPipeRunner : public ConformanceTestRunner {
int read_fd_;
pid_t child_pid_;
std::string executable_;
const std::vector<string> executable_args_;
std::string current_test_name_;
};
@ -257,12 +265,10 @@ class ConformanceTestSuite {
const ConformanceRequestSetting& setting,
Message* test_message) = 0;
void VerifyResponse(
const ConformanceRequestSetting& setting,
const string& equivalent_wire_format,
const conformance::ConformanceResponse& response,
bool need_report_success,
bool require_same_wire_format);
void VerifyResponse(const ConformanceRequestSetting& setting,
const string& equivalent_wire_format,
const conformance::ConformanceResponse& response,
bool need_report_success, bool require_same_wire_format);
void ReportSuccess(const std::string& test_name);
void ReportFailure(const string& test_name,

23
conformance/conformance_test_runner.cc
View File

@ -195,7 +195,8 @@ int ForkPipeRunner::Run(
}
bool all_ok = true;
for (ConformanceTestSuite* suite : suites) {
char *program;
string program;
std::vector<string> program_args;
string failure_list_filename;
conformance::FailureSet failure_list;
@ -221,15 +222,15 @@ int ForkPipeRunner::Run(
UsageError();
}
} else {
if (arg != argc - 1) {
fprintf(stderr, "Too many arguments.\n");
UsageError();
program += argv[arg];
while (arg < argc) {
program_args.push_back(argv[arg]);
arg++;
}
program = argv[arg];
}
}
ForkPipeRunner runner(program);
ForkPipeRunner runner(program, program_args);
std::string output;
all_ok = all_ok &&
@ -295,8 +296,14 @@ void ForkPipeRunner::SpawnTestProgram() {
memcpy(executable.get(), executable_.c_str(), executable_.size());
executable[executable_.size()] = '\0';
char *const argv[] = {executable.get(), NULL};
CHECK_SYSCALL(execv(executable.get(), argv)); // Never returns.
std::vector<const char *> argv;
argv.push_back(executable.get());
for (int i = 0; i < executable_args_.size(); ++i) {
argv.push_back(executable_args_[i].c_str());
}
argv.push_back(nullptr);
// Never returns.
CHECK_SYSCALL(execv(executable.get(), const_cast<char **>(argv.data())));
}
}

BIN
csharp/src/Google.Protobuf.Test/testprotos.pb
View File

Binary file not shown.

9
java/core/src/main/java/com/google/protobuf/AbstractMessageLite.java
View File

@ -146,6 +146,15 @@ public abstract class AbstractMessageLite<
Builder.addAll(values, list);
}
/** Interface for an enum which signifies which field in a {@code oneof} was specified. */
protected interface InternalOneOfEnum {
/**
* Retrieves the field number of the field which was set in this {@code oneof}, or {@code 0} if
* none were.
*/
int getNumber();
}
/**
* A partial implementation of the {@link Message.Builder} interface which implements as many
* methods of that interface as possible in terms of other methods.

10
java/core/src/main/java/com/google/protobuf/GeneratedMessageV3.java
View File

@ -2365,6 +2365,11 @@ public abstract class GeneratedMessageV3 extends AbstractMessage
}
try {
return new MethodHandleInvoker(accessor);
} catch (NoClassDefFoundError e) {
// Fall back to reflection if MethodHandleInvoker isn't available,
// allowing clients that don't want to use method handles to opt out
// by deleting the class.
return accessor;
} catch (IllegalAccessException e) {
throw new RuntimeException(e);
}
@ -2703,6 +2708,11 @@ public abstract class GeneratedMessageV3 extends AbstractMessage
}
try {
return new MethodHandleInvoker(accessor);
} catch (NoClassDefFoundError e) {
// Fall back to reflection if MethodHandleInvoker isn't available,
// allowing clients that don't want to use method handles to opt out
// by deleting the class.
return accessor;
} catch (IllegalAccessException e) {
throw new RuntimeException(e);
}

318
java/core/src/main/java/com/google/protobuf/UnsafeUtil.java
View File

@ -43,6 +43,9 @@ import java.util.logging.Logger;
final class UnsafeUtil {
private static final Logger logger = Logger.getLogger(UnsafeUtil.class.getName());
private static final sun.misc.Unsafe UNSAFE = getUnsafe();
private static final Class<?> MEMORY_CLASS = Android.getMemoryClass();
private static final boolean IS_ANDROID_64 = determineAndroidSupportByAddressSize(long.class);
private static final boolean IS_ANDROID_32 = determineAndroidSupportByAddressSize(int.class);
private static final MemoryAccessor MEMORY_ACCESSOR = getMemoryAccessor();
private static final boolean HAS_UNSAFE_BYTEBUFFER_OPERATIONS =
supportsUnsafeByteBufferOperations();
@ -89,6 +92,9 @@ final class UnsafeUtil {
return HAS_UNSAFE_BYTEBUFFER_OPERATIONS;
}
static boolean isAndroid64() {
return IS_ANDROID_64;
}
@SuppressWarnings("unchecked") // safe by method contract
static <T> T allocateInstance(Class<T> clazz) {
@ -314,6 +320,16 @@ final class UnsafeUtil {
if (UNSAFE == null) {
return null;
}
if (Android.isOnAndroidDevice()) {
if (IS_ANDROID_64) {
return new Android64MemoryAccessor(UNSAFE);
} else if (IS_ANDROID_32) {
return new Android32MemoryAccessor(UNSAFE);
} else {
return null;
}
}
return new JvmMemoryAccessor(UNSAFE);
}
@ -333,6 +349,9 @@ final class UnsafeUtil {
clazz.getMethod("putLong", Object.class, long.class, long.class);
clazz.getMethod("getObject", Object.class, long.class);
clazz.getMethod("putObject", Object.class, long.class, Object.class);
if (Android.isOnAndroidDevice()) {
return true;
}
clazz.getMethod("getByte", Object.class, long.class);
clazz.getMethod("putByte", Object.class, long.class, byte.class);
clazz.getMethod("getBoolean", Object.class, long.class);
@ -365,6 +384,9 @@ final class UnsafeUtil {
return false;
}
if (Android.isOnAndroidDevice()) {
return true;
}
clazz.getMethod("getByte", long.class);
clazz.getMethod("putByte", long.class, byte.class);
clazz.getMethod("getInt", long.class);
@ -382,9 +404,36 @@ final class UnsafeUtil {
return false;
}
private static boolean determineAndroidSupportByAddressSize(Class<?> addressClass) {
if (!Android.isOnAndroidDevice()) {
return false;
}
try {
Class<?> clazz = MEMORY_CLASS;
clazz.getMethod("peekLong", addressClass, boolean.class);
clazz.getMethod("pokeLong", addressClass, long.class, boolean.class);
clazz.getMethod("pokeInt", addressClass, int.class, boolean.class);
clazz.getMethod("peekInt", addressClass, boolean.class);
clazz.getMethod("pokeByte", addressClass, byte.class);
clazz.getMethod("peekByte", addressClass);
clazz.getMethod("pokeByteArray", addressClass, byte[].class, int.class, int.class);
clazz.getMethod("peekByteArray", addressClass, byte[].class, int.class, int.class);
return true;
} catch (Throwable t) {
return false;
}
}
/** Finds the address field within a direct {@link Buffer}. */
private static Field bufferAddressField() {
if (Android.isOnAndroidDevice()) {
// Old versions of Android had renamed the address field to 'effectiveDirectAddress', but
// recent versions of Android (>M?) use the OpenJDK implementation. Fall through in that case.
Field field = field(Buffer.class, "effectiveDirectAddress");
if (field != null) {
return field;
}
}
Field field = field(Buffer.class, "address");
return field != null && field.getType() == long.class ? field : null;
}
@ -656,4 +705,273 @@ final class UnsafeUtil {
}
}
private static final class Android64MemoryAccessor extends MemoryAccessor {
Android64MemoryAccessor(sun.misc.Unsafe unsafe) {
super(unsafe);
}
@Override
public byte getByte(long address) {
throw new UnsupportedOperationException();
}
@Override
public void putByte(long address, byte value) {
throw new UnsupportedOperationException();
}
@Override
public int getInt(long address) {
throw new UnsupportedOperationException();
}
@Override
public void putInt(long address, int value) {
throw new UnsupportedOperationException();
}
@Override
public long getLong(long address) {
throw new UnsupportedOperationException();
}
@Override
public void putLong(long address, long value) {
throw new UnsupportedOperationException();
}
@Override
public byte getByte(Object target, long offset) {
if (IS_BIG_ENDIAN) {
return getByteBigEndian(target, offset);
} else {
return getByteLittleEndian(target, offset);
}
}
@Override
public void putByte(Object target, long offset, byte value) {
if (IS_BIG_ENDIAN) {
putByteBigEndian(target, offset, value);
} else {
putByteLittleEndian(target, offset, value);
}
}
@Override
public boolean getBoolean(Object target, long offset) {
if (IS_BIG_ENDIAN) {
return getBooleanBigEndian(target, offset);
} else {
return getBooleanLittleEndian(target, offset);
}
}
@Override
public void putBoolean(Object target, long offset, boolean value) {
if (IS_BIG_ENDIAN) {
putBooleanBigEndian(target, offset, value);
} else {
putBooleanLittleEndian(target, offset, value);
}
}
@Override
public float getFloat(Object target, long offset) {
return Float.intBitsToFloat(getInt(target, offset));
}
@Override
public void putFloat(Object target, long offset, float value) {
putInt(target, offset, Float.floatToIntBits(value));
}
@Override
public double getDouble(Object target, long offset) {
return Double.longBitsToDouble(getLong(target, offset));
}
@Override
public void putDouble(Object target, long offset, double value) {
putLong(target, offset, Double.doubleToLongBits(value));
}
@Override
public void copyMemory(long srcOffset, byte[] target, long targetIndex, long length) {
throw new UnsupportedOperationException();
}
@Override
public void copyMemory(byte[] src, long srcIndex, long targetOffset, long length) {
throw new UnsupportedOperationException();
}
@Override
public Object getStaticObject(Field field) {
try {
return field.get(null);
} catch (IllegalAccessException e) {
return null;
}
}
}
private static final class Android32MemoryAccessor extends MemoryAccessor {
/** Mask used to convert a 64 bit memory address to a 32 bit address. */
private static final long SMALL_ADDRESS_MASK = 0x00000000FFFFFFFF;
/** Truncate a {@code long} address into a short {@code int} address. */
private static int smallAddress(long address) {
return (int) (SMALL_ADDRESS_MASK & address);
}
Android32MemoryAccessor(sun.misc.Unsafe unsafe) {
super(unsafe);
}
@Override
public byte getByte(long address) {
throw new UnsupportedOperationException();
}
@Override
public void putByte(long address, byte value) {
throw new UnsupportedOperationException();
}
@Override
public int getInt(long address) {
throw new UnsupportedOperationException();
}
@Override
public void putInt(long address, int value) {
throw new UnsupportedOperationException();
}
@Override
public long getLong(long address) {
throw new UnsupportedOperationException();
}
@Override
public void putLong(long address, long value) {
throw new UnsupportedOperationException();
}
@Override
public byte getByte(Object target, long offset) {
if (IS_BIG_ENDIAN) {
return getByteBigEndian(target, offset);
} else {
return getByteLittleEndian(target, offset);
}
}
@Override
public void putByte(Object target, long offset, byte value) {
if (IS_BIG_ENDIAN) {
putByteBigEndian(target, offset, value);
} else {
putByteLittleEndian(target, offset, value);
}
}
@Override
public boolean getBoolean(Object target, long offset) {
if (IS_BIG_ENDIAN) {
return getBooleanBigEndian(target, offset);
} else {
return getBooleanLittleEndian(target, offset);
}
}
@Override
public void putBoolean(Object target, long offset, boolean value) {
if (IS_BIG_ENDIAN) {
putBooleanBigEndian(target, offset, value);
} else {
putBooleanLittleEndian(target, offset, value);
}
}
@Override
public float getFloat(Object target, long offset) {
return Float.intBitsToFloat(getInt(target, offset));
}
@Override
public void putFloat(Object target, long offset, float value) {
putInt(target, offset, Float.floatToIntBits(value));
}
@Override
public double getDouble(Object target, long offset) {
return Double.longBitsToDouble(getLong(target, offset));
}
@Override
public void putDouble(Object target, long offset, double value) {
putLong(target, offset, Double.doubleToLongBits(value));
}
@Override
public void copyMemory(long srcOffset, byte[] target, long targetIndex, long length) {
throw new UnsupportedOperationException();
}
@Override
public void copyMemory(byte[] src, long srcIndex, long targetOffset, long length) {
throw new UnsupportedOperationException();
}
@Override
public Object getStaticObject(Field field) {
try {
return field.get(null);
} catch (IllegalAccessException e) {
return null;
}
}
}
private static byte getByteBigEndian(Object target, long offset) {
return (byte) ((getInt(target, offset & ~3) >>> ((~offset & 3) << 3)) & 0xFF);
}
private static byte getByteLittleEndian(Object target, long offset) {
return (byte) ((getInt(target, offset & ~3) >>> ((offset & 3) << 3)) & 0xFF);
}
private static void putByteBigEndian(Object target, long offset, byte value) {
int intValue = getInt(target, offset & ~3);
int shift = ((~(int) offset) & 3) << 3;
int output = (intValue & ~(0xFF << shift)) | ((0xFF & value) << shift);
putInt(target, offset & ~3, output);
}
private static void putByteLittleEndian(Object target, long offset, byte value) {
int intValue = getInt(target, offset & ~3);
int shift = (((int) offset) & 3) << 3;
int output = (intValue & ~(0xFF << shift)) | ((0xFF & value) << shift);
putInt(target, offset & ~3, output);
}
private static boolean getBooleanBigEndian(Object target, long offset) {
return getByteBigEndian(target, offset) != 0;
}
private static boolean getBooleanLittleEndian(Object target, long offset) {
return getByteLittleEndian(target, offset) != 0;
}
private static void putBooleanBigEndian(Object target, long offset, boolean value) {
putByteBigEndian(target, offset, (byte) (value ? 1 : 0));
}
private static void putBooleanLittleEndian(Object target, long offset, boolean value) {
putByteLittleEndian(target, offset, (byte) (value ? 1 : 0));
}
}

4
java/util/src/main/java/com/google/protobuf/util/FieldMaskUtil.java
View File

@ -345,8 +345,8 @@ public class FieldMaskUtil {
}
/**
* Merges fields specified by a FieldMask from one message to another with the
* specified merge options.
* Merges fields specified by a FieldMask from one message to another with the specified merge
* options. The destination will remain unchanged if an empty FieldMask is provided.
*/
public static void merge(
FieldMask mask, Message source, Message.Builder destination, MergeOptions options) {

12
java/util/src/test/java/com/google/protobuf/util/FieldMaskTreeTest.java
View File

@ -182,11 +182,19 @@ public class FieldMaskTreeTest extends TestCase {
FieldMaskUtil.MergeOptions options = new FieldMaskUtil.MergeOptions();
// Test merging each individual field.
// Test merging with an empty FieldMask.
NestedTestAllTypes.Builder builder = NestedTestAllTypes.newBuilder();
builder.getPayloadBuilder().addRepeatedInt32(1000);
merge(new FieldMaskTree(), source, builder, options, useDynamicMessage);
NestedTestAllTypes.Builder expected = NestedTestAllTypes.newBuilder();
expected.getPayloadBuilder().addRepeatedInt32(1000);
assertEquals(expected.build(), builder.build());
// Test merging each individual field.
builder = NestedTestAllTypes.newBuilder();
merge(new FieldMaskTree().addFieldPath("payload.optional_int32"),
source, builder, options, useDynamicMessage);
NestedTestAllTypes.Builder expected = NestedTestAllTypes.newBuilder();
expected = NestedTestAllTypes.newBuilder();
expected.getPayloadBuilder().setOptionalInt32(1234);
assertEquals(expected.build(), builder.build());

207
js/binary/decoder.js
View File

@ -44,7 +44,6 @@
*/
goog.provide('jspb.BinaryDecoder');
goog.provide('jspb.BinaryIterator');
goog.require('goog.asserts');
goog.require('goog.crypt');
@ -52,164 +51,6 @@ goog.require('jspb.utils');
/**
* Simple helper class for traversing the contents of repeated scalar fields.
* that may or may not have been packed into a wire-format blob.
* @param {?jspb.BinaryDecoder=} opt_decoder
* @param {?function(this:jspb.BinaryDecoder):(number|boolean|string)=}
* opt_next The decoder method to use for next().
* @param {?Array<number|boolean|string>=} opt_elements
* @constructor
* @struct
*/
jspb.BinaryIterator = function(opt_decoder, opt_next, opt_elements) {
/** @private {?jspb.BinaryDecoder} */
this.decoder_ = null;
/**
* The BinaryDecoder member function used when iterating over packed data.
* @private {?function(this:jspb.BinaryDecoder):(number|boolean|string)}
*/
this.nextMethod_ = null;
/** @private {?Array<number|boolean|string>} */
this.elements_ = null;
/** @private {number} */
this.cursor_ = 0;
/** @private {number|boolean|string|null} */
this.nextValue_ = null;
/** @private {boolean} */
this.atEnd_ = true;
this.init_(opt_decoder, opt_next, opt_elements);
};
/**
* @param {?jspb.BinaryDecoder=} opt_decoder
* @param {?function(this:jspb.BinaryDecoder):(number|boolean|string)=}
* opt_next The decoder method to use for next().
* @param {?Array<number|boolean|string>=} opt_elements
* @private
*/
jspb.BinaryIterator.prototype.init_ =
function(opt_decoder, opt_next, opt_elements) {
if (opt_decoder && opt_next) {
this.decoder_ = opt_decoder;
this.nextMethod_ = opt_next;
}
this.elements_ = opt_elements || null;
this.cursor_ = 0;
this.nextValue_ = null;
this.atEnd_ = !this.decoder_ && !this.elements_;
this.next();
};
/**
* Global pool of BinaryIterator instances.
* @private {!Array<!jspb.BinaryIterator>}
*/
jspb.BinaryIterator.instanceCache_ = [];
/**
* Allocates a BinaryIterator from the cache, creating a new one if the cache
* is empty.
* @param {?jspb.BinaryDecoder=} opt_decoder
* @param {?function(this:jspb.BinaryDecoder):(number|boolean|string)=}
* opt_next The decoder method to use for next().
* @param {?Array<number|boolean|string>=} opt_elements
* @return {!jspb.BinaryIterator}
*/
jspb.BinaryIterator.alloc = function(opt_decoder, opt_next, opt_elements) {
if (jspb.BinaryIterator.instanceCache_.length) {
var iterator = jspb.BinaryIterator.instanceCache_.pop();
iterator.init_(opt_decoder, opt_next, opt_elements);
return iterator;
} else {
return new jspb.BinaryIterator(opt_decoder, opt_next, opt_elements);
}
};
/**
* Puts this instance back in the instance cache.
*/
jspb.BinaryIterator.prototype.free = function() {
this.clear();
if (jspb.BinaryIterator.instanceCache_.length < 100) {
jspb.BinaryIterator.instanceCache_.push(this);
}
};
/**
* Clears the iterator.
*/
jspb.BinaryIterator.prototype.clear = function() {
if (this.decoder_) {
this.decoder_.free();
}
this.decoder_ = null;
this.nextMethod_ = null;
this.elements_ = null;
this.cursor_ = 0;
this.nextValue_ = null;
this.atEnd_ = true;
};
/**
* Returns the element at the iterator, or null if the iterator is invalid or
* past the end of the decoder/array.
* @return {number|boolean|string|null}
*/
jspb.BinaryIterator.prototype.get = function() {
return this.nextValue_;
};
/**
* Returns true if the iterator is at the end of the decoder/array.
* @return {boolean}
*/
jspb.BinaryIterator.prototype.atEnd = function() {
return this.atEnd_;
};
/**
* Returns the element at the iterator and steps to the next element,
* equivalent to '*pointer++' in C.
* @return {number|boolean|string|null}
*/
jspb.BinaryIterator.prototype.next = function() {
var lastValue = this.nextValue_;
if (this.decoder_) {
if (this.decoder_.atEnd()) {
this.nextValue_ = null;
this.atEnd_ = true;
} else {
this.nextValue_ = this.nextMethod_.call(this.decoder_);
}
} else if (this.elements_) {
if (this.cursor_ == this.elements_.length) {
this.nextValue_ = null;
this.atEnd_ = true;
} else {
this.nextValue_ = this.elements_[this.cursor_++];
}
}
return lastValue;
};
/**
* BinaryDecoder implements the decoders for all the wire types specified in
* https://developers.google.com/protocol-buffers/docs/encoding.
@ -482,6 +323,32 @@ jspb.BinaryDecoder.prototype.readSplitVarint64 = function(convert) {
};
/**
* Reads a signed zigzag encoded varint from the binary stream and invokes
* the conversion function with the value in two signed 32 bit integers to
* produce the result. Since this does not convert the value to a number, no
* precision is lost.
*
* It's possible for an unsigned varint to be incorrectly encoded - more than
* 64 bits' worth of data could be present. If this happens, this method will
* throw an error.
*
* Zigzag encoding is a modification of varint encoding that reduces the
* storage overhead for small negative integers - for more details on the
* format, see https://developers.google.com/protocol-buffers/docs/encoding
*
* @param {function(number, number): T} convert Conversion function to produce
* the result value, takes parameters (lowBits, highBits).
* @return {T}
* @template T
*/
jspb.BinaryDecoder.prototype.readSplitZigzagVarint64 = function(convert) {
return this.readSplitVarint64(function(low, high) {
return jspb.utils.fromZigzag64(low, high, convert);
});
};
/**
* Reads a 64-bit fixed-width value from the stream and invokes the conversion
* function with the value in two signed 32 bit integers to produce the result.
@ -731,9 +598,25 @@ jspb.BinaryDecoder.prototype.readZigzagVarint64 = function() {
};
/**
* Reads a signed, zigzag-encoded 64-bit varint from the binary stream
* losslessly and returns it as an 8-character Unicode string for use as a hash
* table key.
*
* Zigzag encoding is a modification of varint encoding that reduces the
* storage overhead for small negative integers - for more details on the
* format, see https://developers.google.com/protocol-buffers/docs/encoding
*
* @return {string} The decoded zigzag varint in hash64 format.
*/
jspb.BinaryDecoder.prototype.readZigzagVarintHash64 = function() {
return this.readSplitZigzagVarint64(jspb.utils.joinHash64);
};
/**
* Reads a signed, zigzag-encoded 64-bit varint from the binary stream and
* returns its valud as a string.
* returns its value as a string.
*
* Zigzag encoding is a modification of varint encoding that reduces the
* storage overhead for small negative integers - for more details on the
@ -743,9 +626,7 @@ jspb.BinaryDecoder.prototype.readZigzagVarint64 = function() {
* string.
*/
jspb.BinaryDecoder.prototype.readZigzagVarint64String = function() {
// TODO(haberman): write lossless 64-bit zig-zag math.
var value = this.readZigzagVarint64();
return value.toString();
return this.readSplitZigzagVarint64(jspb.utils.joinSignedDecimalString);
};

89
js/binary/decoder_test.js
View File

@ -235,6 +235,95 @@ describe('binaryDecoderTest', function() {
});
});
describe('sint64', function() {
var /** !jspb.BinaryDecoder */ decoder;
var hashA =
String.fromCharCode(0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00);
var hashB =
String.fromCharCode(0x12, 0x34, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00);
var hashC =
String.fromCharCode(0x12, 0x34, 0x56, 0x78, 0x87, 0x65, 0x43, 0x21);
var hashD =
String.fromCharCode(0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF);
beforeEach(function() {
var encoder = new jspb.BinaryEncoder();
encoder.writeZigzagVarintHash64(hashA);
encoder.writeZigzagVarintHash64(hashB);
encoder.writeZigzagVarintHash64(hashC);
encoder.writeZigzagVarintHash64(hashD);
decoder = jspb.BinaryDecoder.alloc(encoder.end());
});
it('reads 64-bit integers as decimal strings', function() {
const signed = true;
expect(decoder.readZigzagVarint64String())
.toEqual(jspb.utils.hash64ToDecimalString(hashA, signed));
expect(decoder.readZigzagVarint64String())
.toEqual(jspb.utils.hash64ToDecimalString(hashB, signed));
expect(decoder.readZigzagVarint64String())
.toEqual(jspb.utils.hash64ToDecimalString(hashC, signed));
expect(decoder.readZigzagVarint64String())
.toEqual(jspb.utils.hash64ToDecimalString(hashD, signed));
});
it('reads 64-bit integers as hash strings', function() {
expect(decoder.readZigzagVarintHash64()).toEqual(hashA);
expect(decoder.readZigzagVarintHash64()).toEqual(hashB);
expect(decoder.readZigzagVarintHash64()).toEqual(hashC);
expect(decoder.readZigzagVarintHash64()).toEqual(hashD);
});
it('reads split 64 bit zigzag integers', function() {
function hexJoin(bitsLow, bitsHigh) {
return `0x${(bitsHigh >>> 0).toString(16)}:0x${
(bitsLow >>> 0).toString(16)}`;
}
function hexJoinHash(hash64) {
jspb.utils.splitHash64(hash64);
return hexJoin(jspb.utils.split64Low, jspb.utils.split64High);
}
expect(decoder.readSplitZigzagVarint64(hexJoin))
.toEqual(hexJoinHash(hashA));
expect(decoder.readSplitZigzagVarint64(hexJoin))
.toEqual(hexJoinHash(hashB));
expect(decoder.readSplitZigzagVarint64(hexJoin))
.toEqual(hexJoinHash(hashC));
expect(decoder.readSplitZigzagVarint64(hexJoin))
.toEqual(hexJoinHash(hashD));
});
it('does zigzag encoding properly', function() {
// Test cases direcly from the protobuf dev guide.
// https://engdoc.corp.google.com/eng/howto/protocolbuffers/developerguide/encoding.shtml?cl=head#types
var testCases = [
{original: '0', zigzag: '0'},
{original: '-1', zigzag: '1'},
{original: '1', zigzag: '2'},
{original: '-2', zigzag: '3'},
{original: '2147483647', zigzag: '4294967294'},
{original: '-2147483648', zigzag: '4294967295'},
// 64-bit extremes, not in dev guide.
{original: '9223372036854775807', zigzag: '18446744073709551614'},
{original: '-9223372036854775808', zigzag: '18446744073709551615'},
];
var encoder = new jspb.BinaryEncoder();
testCases.forEach(function(c) {
encoder.writeZigzagVarint64String(c.original);
});
var buffer = encoder.end();
var zigzagDecoder = jspb.BinaryDecoder.alloc(buffer);
var varintDecoder = jspb.BinaryDecoder.alloc(buffer);
testCases.forEach(function(c) {
expect(zigzagDecoder.readZigzagVarint64String()).toEqual(c.original);
expect(varintDecoder.readUnsignedVarint64String()).toEqual(c.zigzag);
});
});
});
/**
* Tests reading and writing large strings
*/

22
js/binary/encoder.js
View File

@ -232,13 +232,27 @@ jspb.BinaryEncoder.prototype.writeZigzagVarint64 = function(value) {
* @param {string} value The integer to convert.
*/
jspb.BinaryEncoder.prototype.writeZigzagVarint64String = function(value) {
// TODO(haberman): write lossless 64-bit zig-zag math.
this.writeZigzagVarint64(parseInt(value, 10));
this.writeZigzagVarintHash64(jspb.utils.decimalStringToHash64(value));
};
/**
* Writes a 8-bit unsigned integer to the buffer. Numbers outside the range
* Writes a 64-bit hash string (8 characters @ 8 bits of data each) to the
* buffer as a zigzag varint.
* @param {string} hash The hash to write.
*/
jspb.BinaryEncoder.prototype.writeZigzagVarintHash64 = function(hash) {
var self = this;
jspb.utils.splitHash64(hash);
jspb.utils.toZigzag64(
jspb.utils.split64Low, jspb.utils.split64High, function(lo, hi) {
self.writeSplitVarint64(lo >>> 0, hi >>> 0);
});
};
/**
* Writes an 8-bit unsigned integer to the buffer. Numbers outside the range
* [0,2^8) will be truncated.
* @param {number} value The value to write.
*/
@ -294,7 +308,7 @@ jspb.BinaryEncoder.prototype.writeUint64 = function(value) {
/**
* Writes a 8-bit integer to the buffer. Numbers outside the range
* Writes an 8-bit integer to the buffer. Numbers outside the range
* [-2^7,2^7) will be truncated.
* @param {number} value The value to write.
*/

36
js/binary/reader.js
View File

@ -49,6 +49,7 @@ goog.provide('jspb.BinaryReader');
goog.require('goog.asserts');
goog.require('jspb.BinaryConstants');
goog.require('jspb.BinaryDecoder');
goog.require('jspb.utils');
@ -941,7 +942,7 @@ jspb.BinaryReader.prototype.readBytes = function() {
/**
* Reads a 64-bit varint or fixed64 field from the stream and returns it as a
* Reads a 64-bit varint or fixed64 field from the stream and returns it as an
* 8-character Unicode string for use as a hash table key, or throws an error
* if the next field in the stream is not of the correct wire type.
*
@ -954,6 +955,20 @@ jspb.BinaryReader.prototype.readVarintHash64 = function() {
};
/**
* Reads an sint64 field from the stream and returns it as an 8-character
* Unicode string for use as a hash table key, or throws an error if the next
* field in the stream is not of the correct wire type.
*
* @return {string} The hash value.
*/
jspb.BinaryReader.prototype.readSintHash64 = function() {
goog.asserts.assert(
this.nextWireType_ == jspb.BinaryConstants.WireType.VARINT);
return this.decoder_.readZigzagVarintHash64();
};
/**
* Reads a 64-bit varint field from the stream and invokes `convert` to produce
* the return value, or throws an error if the next field in the stream is not
@ -971,6 +986,25 @@ jspb.BinaryReader.prototype.readSplitVarint64 = function(convert) {
};
/**
* Reads a 64-bit zig-zag varint field from the stream and invokes `convert` to
* produce the return value, or throws an error if the next field in the stream
* is not of the correct wire type.
*
* @param {function(number, number): T} convert Conversion function to produce
* the result value, takes parameters (lowBits, highBits).
* @return {T}
* @template T
*/
jspb.BinaryReader.prototype.readSplitZigzagVarint64 = function(convert) {
goog.asserts.assert(
this.nextWireType_ == jspb.BinaryConstants.WireType.VARINT);
return this.decoder_.readSplitVarint64(function(lowBits, highBits) {
return jspb.utils.fromZigzag64(lowBits, highBits, convert);
});
};
/**
* Reads a 64-bit varint or fixed64 field from the stream and returns it as a
* 8-character Unicode string for use as a hash table key, or throws an error

10
js/binary/reader_test.js
View File

@ -414,6 +414,7 @@ describe('binaryReaderTest', function() {
var writer = new jspb.BinaryWriter();
writer.writeInt64String(1, '4294967296');
writer.writeSfixed64String(2, '4294967298');
writer.writeInt64String(3, '3'); // 3 is the zig-zag encoding of -2.
var reader = jspb.BinaryReader.alloc(writer.getResultBuffer());
function rejoin(lowBits, highBits) {
@ -426,6 +427,10 @@ describe('binaryReaderTest', function() {
reader.nextField();
expect(reader.getFieldNumber()).toEqual(2);
expect(reader.readSplitFixed64(rejoin)).toEqual(0x100000002);
reader.nextField();
expect(reader.getFieldNumber()).toEqual(3);
expect(reader.readSplitZigzagVarint64(rejoin)).toEqual(-2);
});
/**
@ -490,6 +495,11 @@ describe('binaryReaderTest', function() {
jspb.BinaryReader.prototype.readSint64,
jspb.BinaryWriter.prototype.writeSint64,
1, -Math.pow(2, 63), Math.pow(2, 63) - 513, Math.round);
doTestSignedField_(
jspb.BinaryReader.prototype.readSintHash64,
jspb.BinaryWriter.prototype.writeSintHash64, 1, -Math.pow(2, 63),
Math.pow(2, 63) - 513, jspb.utils.numberToHash64);
});

67
js/binary/utils.js
View File

@ -296,7 +296,7 @@ jspb.utils.splitHash64 = function(hash) {
* @return {number}
*/
jspb.utils.joinUint64 = function(bitsLow, bitsHigh) {
return bitsHigh * jspb.BinaryConstants.TWO_TO_32 + bitsLow;
return bitsHigh * jspb.BinaryConstants.TWO_TO_32 + (bitsLow >>> 0);
};
@ -322,6 +322,33 @@ jspb.utils.joinInt64 = function(bitsLow, bitsHigh) {
return sign ? -result : result;
};
/**
* Converts split 64-bit values from standard two's complement encoding to
* zig-zag encoding. Invokes the provided function to produce final result.
*
* @param {number} bitsLow
* @param {number} bitsHigh
* @param {function(number, number): T} convert Conversion function to produce
* the result value, takes parameters (lowBits, highBits).
* @return {T}
* @template T
*/
jspb.utils.toZigzag64 = function(bitsLow, bitsHigh, convert) {
// See
// https://engdoc.corp.google.com/eng/howto/protocolbuffers/developerguide/encoding.shtml?cl=head#types
// 64-bit math is: (n << 1) ^ (n >> 63)
//
// To do this in 32 bits, we can get a 32-bit sign-flipping mask from the
// high word.
// Then we can operate on each word individually, with the addition of the
// "carry" to get the most significant bit from the low word into the high
// word.
var signFlipMask = bitsHigh >> 31;
bitsHigh = (bitsHigh << 1 | bitsLow >>> 31) ^ signFlipMask;
bitsLow = (bitsLow << 1) ^ signFlipMask;
return convert(bitsLow, bitsHigh);
};
/**
* Joins two 32-bit values into a 64-bit unsigned integer and applies zigzag
@ -331,21 +358,33 @@ jspb.utils.joinInt64 = function(bitsLow, bitsHigh) {
* @return {number}
*/
jspb.utils.joinZigzag64 = function(bitsLow, bitsHigh) {
// Extract the sign bit and shift right by one.
var sign = bitsLow & 1;
bitsLow = ((bitsLow >>> 1) | (bitsHigh << 31)) >>> 0;
bitsHigh = bitsHigh >>> 1;
return jspb.utils.fromZigzag64(bitsLow, bitsHigh, jspb.utils.joinInt64);
};
// Increment the split value if the sign bit was set.
if (sign) {
bitsLow = (bitsLow + 1) >>> 0;
if (bitsLow == 0) {
bitsHigh = (bitsHigh + 1) >>> 0;
}
}
var result = jspb.utils.joinUint64(bitsLow, bitsHigh);
return sign ? -result : result;
/**
* Converts split 64-bit values from zigzag encoding to standard two's
* complement encoding. Invokes the provided function to produce final result.
*
* @param {number} bitsLow
* @param {number} bitsHigh
* @param {function(number, number): T} convert Conversion function to produce
* the result value, takes parameters (lowBits, highBits).
* @return {T}
* @template T
*/
jspb.utils.fromZigzag64 = function(bitsLow, bitsHigh, convert) {
// 64 bit math is:
// signmask = (zigzag & 1) ? -1 : 0;
// twosComplement = (zigzag >> 1) ^ signmask;
//
// To work with 32 bit, we can operate on both but "carry" the lowest bit
// from the high word by shifting it up 31 bits to be the most significant bit
// of the low word.
var signFlipMask = -(bitsLow & 1);
bitsLow = ((bitsLow >>> 1) | (bitsHigh << 31)) ^ signFlipMask;
bitsHigh = (bitsHigh >>> 1) ^ signFlipMask;
return convert(bitsLow, bitsHigh);
};

47
js/binary/utils_test.js
View File

@ -465,6 +465,53 @@ describe('binaryUtilsTest', function() {
}
});
/**
* Tests zigzag conversions.
*/
it('can encode and decode zigzag 64', function() {
function stringToHiLoPair(str) {
jspb.utils.splitDecimalString(str);
return {
lo: jspb.utils.split64Low >>> 0,
hi: jspb.utils.split64High >>> 0
};
}
function makeHiLoPair(lo, hi) {
return {lo: lo >>> 0, hi: hi >>> 0};
}
// Test cases direcly from the protobuf dev guide.
// https://engdoc.corp.google.com/eng/howto/protocolbuffers/developerguide/encoding.shtml?cl=head#types
var testCases = [
{original: stringToHiLoPair('0'), zigzag: stringToHiLoPair('0')},
{original: stringToHiLoPair('-1'), zigzag: stringToHiLoPair('1')},
{original: stringToHiLoPair('1'), zigzag: stringToHiLoPair('2')},
{original: stringToHiLoPair('-2'), zigzag: stringToHiLoPair('3')},
{
original: stringToHiLoPair('2147483647'),
zigzag: stringToHiLoPair('4294967294')
},
{
original: stringToHiLoPair('-2147483648'),
zigzag: stringToHiLoPair('4294967295')
},
// 64-bit extremes
{
original: stringToHiLoPair('9223372036854775807'),
zigzag: stringToHiLoPair('18446744073709551614')
},
{
original: stringToHiLoPair('-9223372036854775808'),
zigzag: stringToHiLoPair('18446744073709551615')
},
];
for (const c of testCases) {
expect(jspb.utils.toZigzag64(c.original.lo, c.original.hi, makeHiLoPair))
.toEqual(c.zigzag);
expect(jspb.utils.fromZigzag64(c.zigzag.lo, c.zigzag.hi, makeHiLoPair))
.toEqual(c.original);
}
});
/**
* Tests counting packed varints.

130
js/binary/writer.js
View File

@ -236,12 +236,11 @@ jspb.BinaryWriter.prototype.getResultBuffer = function() {
/**
* Converts the encoded data into a base64-encoded string.
* @param {boolean=} opt_webSafe True indicates we should use a websafe
* alphabet, which does not require escaping for use in URLs.
* @param {!goog.crypt.base64.Alphabet=} alphabet Which flavor of base64 to use.
* @return {string}
*/
jspb.BinaryWriter.prototype.getResultBase64String = function(opt_webSafe) {
return goog.crypt.base64.encodeByteArray(this.getResultBuffer(), opt_webSafe);
jspb.BinaryWriter.prototype.getResultBase64String = function(alphabet) {
return goog.crypt.base64.encodeByteArray(this.getResultBuffer(), alphabet);
};
@ -450,6 +449,19 @@ jspb.BinaryWriter.prototype.writeZigzagVarint64String_ = function(
};
/**
* Writes a zigzag varint field to the buffer without range checking.
* @param {number} field The field number.
* @param {string?} value The value to write.
* @private
*/
jspb.BinaryWriter.prototype.writeZigzagVarintHash64_ = function(field, value) {
if (value == null) return;
this.writeFieldHeader_(field, jspb.BinaryConstants.WireType.VARINT);
this.encoder_.writeZigzagVarintHash64(value);
};
/**
* Writes an int32 field to the buffer. Numbers outside the range [-2^31,2^31)
* will be truncated.
@ -563,7 +575,7 @@ jspb.BinaryWriter.prototype.writeUint64String = function(field, value) {
/**
* Writes a sint32 field to the buffer. Numbers outside the range [-2^31,2^31)
* Writes an sint32 field to the buffer. Numbers outside the range [-2^31,2^31)
* will be truncated.
* @param {number} field The field number.
* @param {number?} value The value to write.
@ -577,7 +589,7 @@ jspb.BinaryWriter.prototype.writeSint32 = function(field, value) {
/**
* Writes a sint64 field to the buffer. Numbers outside the range [-2^63,2^63)
* Writes an sint64 field to the buffer. Numbers outside the range [-2^63,2^63)
* will be truncated.
* @param {number} field The field number.
* @param {number?} value The value to write.
@ -591,15 +603,25 @@ jspb.BinaryWriter.prototype.writeSint64 = function(field, value) {
/**
* Writes a sint64 field to the buffer. Numbers outside the range [-2^63,2^63)
* Writes an sint64 field to the buffer from a hash64 encoded value. Numbers
* outside the range [-2^63,2^63) will be truncated.
* @param {number} field The field number.
* @param {string?} value The hash64 string to write.
*/
jspb.BinaryWriter.prototype.writeSintHash64 = function(field, value) {
if (value == null) return;
this.writeZigzagVarintHash64_(field, value);
};
/**
* Writes an sint64 field to the buffer. Numbers outside the range [-2^63,2^63)
* will be truncated.
* @param {number} field The field number.
* @param {string?} value The decimal string to write.
*/
jspb.BinaryWriter.prototype.writeSint64String = function(field, value) {
if (value == null) return;
goog.asserts.assert((+value >= -jspb.BinaryConstants.TWO_TO_63) &&
(+value < jspb.BinaryConstants.TWO_TO_63));
this.writeZigzagVarint64String_(field, value);
};
@ -912,6 +934,22 @@ jspb.BinaryWriter.prototype.writeSplitVarint64 = function(
};
/**
* Writes a 64-bit field to the buffer as a zigzag encoded varint.
* @param {number} field The field number.
* @param {number} lowBits The low 32 bits.
* @param {number} highBits The high 32 bits.
*/
jspb.BinaryWriter.prototype.writeSplitZigzagVarint64 = function(
field, lowBits, highBits) {
this.writeFieldHeader_(field, jspb.BinaryConstants.WireType.VARINT);
var encoder = this.encoder_;
jspb.utils.toZigzag64(lowBits, highBits, function(lowBits, highBits) {
encoder.writeSplitVarint64(lowBits >>> 0, highBits >>> 0);
});
};
/**
* Writes an array of numbers to the buffer as a repeated 32-bit int field.
* @param {number} field The field number.
@ -986,6 +1024,23 @@ jspb.BinaryWriter.prototype.writeRepeatedSplitVarint64 = function(
};
/**
* Writes an array of 64-bit values to the buffer as a zigzag varint.
* @param {number} field The field number.
* @param {?Array<T>} value The value.
* @param {function(T): number} lo Function to get low bits.
* @param {function(T): number} hi Function to get high bits.
* @template T
*/
jspb.BinaryWriter.prototype.writeRepeatedSplitZigzagVarint64 = function(
field, value, lo, hi) {
if (value == null) return;
for (var i = 0; i < value.length; i++) {
this.writeSplitZigzagVarint64(field, lo(value[i]), hi(value[i]));
}
};
/**
* Writes an array of numbers formatted as strings to the buffer as a repeated
* 64-bit int field.
@ -1095,6 +1150,20 @@ jspb.BinaryWriter.prototype.writeRepeatedSint64String = function(field, value) {
};
/**
* Writes an array of hash64 strings to the buffer as a repeated signed 64-bit
* int field.
* @param {number} field The field number.
* @param {?Array<string>} value The array of ints to write.
*/
jspb.BinaryWriter.prototype.writeRepeatedSintHash64 = function(field, value) {
if (value == null) return;
for (var i = 0; i < value.length; i++) {
this.writeZigzagVarintHash64_(field, value[i]);
}
};
/**
* Writes an array of numbers to the buffer as a repeated fixed32 field. This
* works for both signed and unsigned fixed32s.
@ -1411,6 +1480,29 @@ jspb.BinaryWriter.prototype.writePackedSplitVarint64 = function(
};
/**
* Writes an array of 64-bit values to the buffer as a zigzag varint.
* @param {number} field The field number.
* @param {?Array<T>} value The value.
* @param {function(T): number} lo Function to get low bits.
* @param {function(T): number} hi Function to get high bits.
* @template T
*/
jspb.BinaryWriter.prototype.writePackedSplitZigzagVarint64 = function(
field, value, lo, hi) {
if (value == null) return;
var bookmark = this.beginDelimited_(field);
var encoder = this.encoder_;
for (var i = 0; i < value.length; i++) {
jspb.utils.toZigzag64(
lo(value[i]), hi(value[i]), function(bitsLow, bitsHigh) {
encoder.writeSplitVarint64(bitsLow >>> 0, bitsHigh >>> 0);
});
}
this.endDelimited_(bookmark);
};
/**
* Writes an array of numbers represented as strings to the buffer as a packed
* 64-bit int field.
@ -1533,8 +1625,24 @@ jspb.BinaryWriter.prototype.writePackedSint64String = function(field, value) {
if (value == null || !value.length) return;
var bookmark = this.beginDelimited_(field);
for (var i = 0; i < value.length; i++) {
// TODO(haberman): make lossless
this.encoder_.writeZigzagVarint64(parseInt(value[i], 10));
this.encoder_.writeZigzagVarintHash64(
jspb.utils.decimalStringToHash64(value[i]));
}
this.endDelimited_(bookmark);
};
/**
* Writes an array of hash 64 strings to the buffer as a packed signed 64-bit
* int field.
* @param {number} field The field number.
* @param {?Array<string>} value The array of decimal strings to write.
*/
jspb.BinaryWriter.prototype.writePackedSintHash64 = function(field, value) {
if (value == null || !value.length) return;
var bookmark = this.beginDelimited_(field);
for (var i = 0; i < value.length; i++) {
this.encoder_.writeZigzagVarintHash64(value[i]);
}
this.endDelimited_(bookmark);
};

122
js/binary/writer_test.js
View File

@ -42,6 +42,7 @@ goog.require('goog.crypt');
goog.require('goog.testing.asserts');
goog.require('jspb.BinaryReader');
goog.require('jspb.BinaryWriter');
goog.require('jspb.utils');
/**
@ -128,8 +129,13 @@ describe('binaryWriterTest', function() {
var writer = new jspb.BinaryWriter();
writer.writeBytes(1, new Uint8Array([127]));
assertEquals('CgF/', writer.getResultBase64String());
assertEquals('CgF/', writer.getResultBase64String(false));
assertEquals('CgF_', writer.getResultBase64String(true));
assertEquals(
'CgF/',
writer.getResultBase64String(goog.crypt.base64.Alphabet.DEFAULT));
assertEquals(
'CgF_',
writer.getResultBase64String(
goog.crypt.base64.Alphabet.WEBSAFE_NO_PADDING));
});
it('writes split 64 fields', function() {
@ -201,4 +207,116 @@ describe('binaryWriterTest', function() {
String(4 * 2 ** 32 + 3),
]);
});
it('writes zigzag 64 fields', function() {
// Test cases direcly from the protobuf dev guide.
// https://engdoc.corp.google.com/eng/howto/protocolbuffers/developerguide/encoding.shtml?cl=head#types
var testCases = [
{original: '0', zigzag: '0'},
{original: '-1', zigzag: '1'},
{original: '1', zigzag: '2'},
{original: '-2', zigzag: '3'},
{original: '2147483647', zigzag: '4294967294'},
{original: '-2147483648', zigzag: '4294967295'},
// 64-bit extremes, not in dev guide.
{original: '9223372036854775807', zigzag: '18446744073709551614'},
{original: '-9223372036854775808', zigzag: '18446744073709551615'},
];
function decimalToLowBits(v) {
jspb.utils.splitDecimalString(v);
return jspb.utils.split64Low >>> 0;
}
function decimalToHighBits(v) {
jspb.utils.splitDecimalString(v);
return jspb.utils.split64High >>> 0;
}
var writer = new jspb.BinaryWriter();
testCases.forEach(function(c) {
writer.writeSint64String(1, c.original);
writer.writeSintHash64(1, jspb.utils.decimalStringToHash64(c.original));
jspb.utils.splitDecimalString(c.original);
writer.writeSplitZigzagVarint64(
1, jspb.utils.split64Low, jspb.utils.split64High);
});
writer.writeRepeatedSint64String(2, testCases.map(function(c) {
return c.original;
}));
writer.writeRepeatedSintHash64(3, testCases.map(function(c) {
return jspb.utils.decimalStringToHash64(c.original);
}));
writer.writeRepeatedSplitZigzagVarint64(
4, testCases.map(function(c) {
return c.original;
}),
decimalToLowBits, decimalToHighBits);
writer.writePackedSint64String(5, testCases.map(function(c) {
return c.original;
}));
writer.writePackedSintHash64(6, testCases.map(function(c) {
return jspb.utils.decimalStringToHash64(c.original);
}));
writer.writePackedSplitZigzagVarint64(
7, testCases.map(function(c) {
return c.original;
}),
decimalToLowBits, decimalToHighBits);
// Verify by reading the stream as normal int64 fields and checking with
// the canonical zigzag encoding of each value.
var reader = jspb.BinaryReader.alloc(writer.getResultBuffer());
testCases.forEach(function(c) {
reader.nextField();
expect(reader.getFieldNumber()).toEqual(1);
expect(reader.readUint64String()).toEqual(c.zigzag);
reader.nextField();
expect(reader.getFieldNumber()).toEqual(1);
expect(reader.readUint64String()).toEqual(c.zigzag);
reader.nextField();
expect(reader.getFieldNumber()).toEqual(1);
expect(reader.readUint64String()).toEqual(c.zigzag);
});
testCases.forEach(function(c) {
reader.nextField();
expect(reader.getFieldNumber()).toEqual(2);
expect(reader.readUint64String()).toEqual(c.zigzag);
});
testCases.forEach(function(c) {
reader.nextField();
expect(reader.getFieldNumber()).toEqual(3);
expect(reader.readUint64String()).toEqual(c.zigzag);
});
testCases.forEach(function(c) {
reader.nextField();
expect(reader.getFieldNumber()).toEqual(4);
expect(reader.readUint64String()).toEqual(c.zigzag);
});
reader.nextField();
expect(reader.getFieldNumber()).toEqual(5);
expect(reader.readPackedUint64String()).toEqual(testCases.map(function(c) {
return c.zigzag;
}));
reader.nextField();
expect(reader.getFieldNumber()).toEqual(6);
expect(reader.readPackedUint64String()).toEqual(testCases.map(function(c) {
return c.zigzag;
}));
reader.nextField();
expect(reader.getFieldNumber()).toEqual(7);
expect(reader.readPackedUint64String()).toEqual(testCases.map(function(c) {
return c.zigzag;
}));
});
});

6
js/compatibility_tests/v3.0.0/binary/proto_test.js
View File

@ -172,7 +172,7 @@ function fillAllFields(msg) {
* @return {boolean}
*/
function bytesCompare(arr, expected) {
if (goog.isString(arr)) {
if (typeof arr === 'string') {
arr = goog.crypt.base64.decodeStringToUint8Array(arr);
}
if (arr.length != expected.length) {
@ -477,8 +477,8 @@ describe('protoBinaryTest', function() {
var msg = new proto.jspb.test.TestAllTypes();
function assertGetters() {
assertTrue(goog.isString(msg.getRepeatedBytesList_asB64()[0]));
assertTrue(goog.isString(msg.getRepeatedBytesList_asB64()[1]));
assertTrue(typeof msg.getRepeatedBytesList_asB64()[0] === 'string');
assertTrue(typeof msg.getRepeatedBytesList_asB64()[1] === 'string');
assertTrue(msg.getRepeatedBytesList_asU8()[0] instanceof Uint8Array);
assertTrue(msg.getRepeatedBytesList_asU8()[1] instanceof Uint8Array);

6
js/compatibility_tests/v3.0.0/binary/utils_test.js
View File

@ -355,7 +355,7 @@ describe('binaryUtilsTest', function() {
*/
function test(x, opt_bits) {
jspb.utils.splitFloat32(x);
if (goog.isDef(opt_bits)) {
if (opt_bits !== undefined) {
if (opt_bits != jspb.utils.split64Low) throw 'fail!';
}
if (truncate(x) != jspb.utils.joinFloat32(jspb.utils.split64Low,
@ -422,10 +422,10 @@ describe('binaryUtilsTest', function() {
*/
function test(x, opt_highBits, opt_lowBits) {
jspb.utils.splitFloat64(x);
if (goog.isDef(opt_highBits)) {
if (opt_highBits !== undefined) {
if (opt_highBits != jspb.utils.split64High) throw 'fail!';
}
if (goog.isDef(opt_lowBits)) {
if (opt_lowBits !== undefined) {
if (opt_lowBits != jspb.utils.split64Low) throw 'fail!';
}
if (x != jspb.utils.joinFloat64(jspb.utils.split64Low,

5
js/compatibility_tests/v3.0.0/message_test.js
View File

@ -1057,8 +1057,9 @@ describe('Message test suite', function() {
it('testFloatingPointFieldsSupportNan', function() {
var assertNan = function(x) {
assertTrue('Expected ' + x + ' (' + goog.typeOf(x) + ') to be NaN.',
goog.isNumber(x) && isNaN(x));
assertTrue(
'Expected ' + x + ' (' + goog.typeOf(x) + ') to be NaN.',
typeof x === 'number' && isNaN(x));
};
var message = new proto.jspb.test.FloatingPointFields([

2
js/compatibility_tests/v3.0.0/proto3_test.js
View File

@ -50,7 +50,7 @@ var BYTES_B64 = goog.crypt.base64.encodeByteArray(BYTES);
* @return {boolean}
*/
function bytesCompare(arr, expected) {
if (goog.isString(arr)) {
if (typeof arr === 'string') {
arr = goog.crypt.base64.decodeStringToUint8Array(arr);
}
if (arr.length != expected.length) {

6
js/compatibility_tests/v3.1.0/binary/proto_test.js
View File

@ -172,7 +172,7 @@ function fillAllFields(msg) {
* @return {boolean}
*/
function bytesCompare(arr, expected) {
if (goog.isString(arr)) {
if (typeof arr === 'string') {
arr = goog.crypt.base64.decodeStringToUint8Array(arr);
}
if (arr.length != expected.length) {
@ -477,8 +477,8 @@ describe('protoBinaryTest', function() {
var msg = new proto.jspb.test.TestAllTypes();
function assertGetters() {
assertTrue(goog.isString(msg.getRepeatedBytesList_asB64()[0]));
assertTrue(goog.isString(msg.getRepeatedBytesList_asB64()[1]));
assertTrue(typeof msg.getRepeatedBytesList_asB64()[0] === 'string');
assertTrue(typeof msg.getRepeatedBytesList_asB64()[1] === 'string');
assertTrue(msg.getRepeatedBytesList_asU8()[0] instanceof Uint8Array);
assertTrue(msg.getRepeatedBytesList_asU8()[1] instanceof Uint8Array);

6
js/compatibility_tests/v3.1.0/binary/utils_test.js
View File

@ -355,7 +355,7 @@ describe('binaryUtilsTest', function() {
*/
function test(x, opt_bits) {
jspb.utils.splitFloat32(x);
if (goog.isDef(opt_bits)) {
if (opt_bits !== undefined) {
if (opt_bits != jspb.utils.split64Low) throw 'fail!';
}
if (truncate(x) != jspb.utils.joinFloat32(jspb.utils.split64Low,
@ -422,10 +422,10 @@ describe('binaryUtilsTest', function() {
*/
function test(x, opt_highBits, opt_lowBits) {
jspb.utils.splitFloat64(x);
if (goog.isDef(opt_highBits)) {
if (opt_highBits !== undefined) {
if (opt_highBits != jspb.utils.split64High) throw 'fail!';
}
if (goog.isDef(opt_lowBits)) {
if (opt_lowBits !== undefined) {
if (opt_lowBits != jspb.utils.split64Low) throw 'fail!';
}
if (x != jspb.utils.joinFloat64(jspb.utils.split64Low,

5
js/compatibility_tests/v3.1.0/message_test.js
View File

@ -1009,8 +1009,9 @@ describe('Message test suite', function() {
it('testFloatingPointFieldsSupportNan', function() {
var assertNan = function(x) {
assertTrue('Expected ' + x + ' (' + goog.typeOf(x) + ') to be NaN.',
goog.isNumber(x) && isNaN(x));
assertTrue(
'Expected ' + x + ' (' + goog.typeOf(x) + ') to be NaN.',
typeof x === 'number' && isNaN(x));
};
var message = new proto.jspb.test.FloatingPointFields([

2
js/compatibility_tests/v3.1.0/proto3_test.js
View File

@ -50,7 +50,7 @@ var BYTES_B64 = goog.crypt.base64.encodeByteArray(BYTES);
* @return {boolean}
*/
function bytesCompare(arr, expected) {
if (goog.isString(arr)) {
if (typeof arr === 'string') {
arr = goog.crypt.base64.decodeStringToUint8Array(arr);
}
if (arr.length != expected.length) {

22
js/map.js
View File

@ -461,15 +461,21 @@ jspb.Map.prototype.serializeBinary = function(
* The BinaryReader parsing callback for type V, if V is a message type
*
* @param {K=} opt_defaultKey
* The default value for the type of map keys. Accepting map
* entries with unset keys is required for maps to be backwards compatible
* with the repeated message representation described here: goo.gl/zuoLAC
* The default value for the type of map keys. Accepting map entries with
* unset keys is required for maps to be backwards compatible with the
* repeated message representation described here: goo.gl/zuoLAC
*
* @param {V=} opt_defaultValue
* The default value for the type of map values. Accepting map entries with
* unset values is required for maps to be backwards compatible with the
* repeated message representation described here: goo.gl/zuoLAC
*
*/
jspb.Map.deserializeBinary = function(map, reader, keyReaderFn, valueReaderFn,
opt_valueReaderCallback, opt_defaultKey) {
opt_valueReaderCallback, opt_defaultKey,
opt_defaultValue) {
var key = opt_defaultKey;
var value = undefined;
var value = opt_defaultValue;
while (reader.nextField()) {
if (reader.isEndGroup()) {
@ -484,7 +490,11 @@ jspb.Map.deserializeBinary = function(map, reader, keyReaderFn, valueReaderFn,
// Value.
if (map.valueCtor_) {
goog.asserts.assert(opt_valueReaderCallback);
value = new map.valueCtor_();
if (!value) {
// Old generator still doesn't provide default value message.
// Need this for backward compatibility.
value = new map.valueCtor_();
}
valueReaderFn.call(reader, value, opt_valueReaderCallback);
} else {
value =

80
js/maps_test.js
View File

@ -36,10 +36,18 @@ goog.require('proto.jspb.test.MapValueEnum');
goog.require('proto.jspb.test.MapValueMessage');
goog.require('proto.jspb.test.TestMapFields');
goog.require('proto.jspb.test.TestMapFieldsOptionalKeys');
goog.require('proto.jspb.test.TestMapFieldsOptionalValues');
goog.require('proto.jspb.test.MapEntryOptionalKeysStringKey');
goog.require('proto.jspb.test.MapEntryOptionalKeysInt32Key');
goog.require('proto.jspb.test.MapEntryOptionalKeysInt64Key');
goog.require('proto.jspb.test.MapEntryOptionalKeysBoolKey');
goog.require('proto.jspb.test.MapEntryOptionalValuesStringValue');
goog.require('proto.jspb.test.MapEntryOptionalValuesInt32Value');
goog.require('proto.jspb.test.MapEntryOptionalValuesInt64Value');
goog.require('proto.jspb.test.MapEntryOptionalValuesBoolValue');
goog.require('proto.jspb.test.MapEntryOptionalValuesDoubleValue');
goog.require('proto.jspb.test.MapEntryOptionalValuesEnumValue');
goog.require('proto.jspb.test.MapEntryOptionalValuesMessageValue');
// CommonJS-LoadFromFile: test_pb proto.jspb.test
goog.require('proto.jspb.test.MapValueMessageNoBinary');
@ -54,7 +62,12 @@ function checkMapEquals(map, entries) {
var arr = map.toArray();
assertEquals(arr.length, entries.length);
for (var i = 0; i < arr.length; i++) {
assertElementsEquals(arr[i], entries[i]);
if (Array.isArray(arr[i])) {
assertTrue(Array.isArray(entries[i]));
assertArrayEquals(arr[i], entries[i]);
} else {
assertElementsEquals(arr[i], entries[i]);
}
}
}
@ -265,8 +278,10 @@ function makeTests(msgInfo, submessageCtor, suffix) {
var decoded = msgInfo.deserializeBinary(serialized);
checkMapFields(decoded);
});
/**
* Tests deserialization of undefined map keys go to default values in binary format.
* Tests deserialization of undefined map keys go to default values in
* binary format.
*/
it('testMapDeserializationForUndefinedKeys', function() {
var testMessageOptionalKeys = new proto.jspb.test.TestMapFieldsOptionalKeys();
@ -298,6 +313,67 @@ function makeTests(msgInfo, submessageCtor, suffix) {
[false, 'd']
]);
});
/**
* Tests deserialization of undefined map values go to default values in
* binary format.
*/
it('testMapDeserializationForUndefinedValues', function() {
var testMessageOptionalValues =
new proto.jspb.test.TestMapFieldsOptionalValues();
var mapEntryStringValue =
new proto.jspb.test.MapEntryOptionalValuesStringValue();
mapEntryStringValue.setKey("a");
testMessageOptionalValues.setMapStringString(mapEntryStringValue);
var mapEntryInt32Value =
new proto.jspb.test.MapEntryOptionalValuesInt32Value();
mapEntryInt32Value.setKey("b");
testMessageOptionalValues.setMapStringInt32(mapEntryInt32Value);
var mapEntryInt64Value =
new proto.jspb.test.MapEntryOptionalValuesInt64Value();
mapEntryInt64Value.setKey("c");
testMessageOptionalValues.setMapStringInt64(mapEntryInt64Value);
var mapEntryBoolValue =
new proto.jspb.test.MapEntryOptionalValuesBoolValue();
mapEntryBoolValue.setKey("d");
testMessageOptionalValues.setMapStringBool(mapEntryBoolValue);
var mapEntryDoubleValue =
new proto.jspb.test.MapEntryOptionalValuesDoubleValue();
mapEntryDoubleValue.setKey("e");
testMessageOptionalValues.setMapStringDouble(mapEntryDoubleValue);
var mapEntryEnumValue =
new proto.jspb.test.MapEntryOptionalValuesEnumValue();
mapEntryEnumValue.setKey("f");
testMessageOptionalValues.setMapStringEnum(mapEntryEnumValue);
var mapEntryMessageValue =
new proto.jspb.test.MapEntryOptionalValuesMessageValue();
mapEntryMessageValue.setKey("g");
testMessageOptionalValues.setMapStringMsg(mapEntryMessageValue);
var deserializedMessage = msgInfo.deserializeBinary(
testMessageOptionalValues.serializeBinary()
);
checkMapEquals(deserializedMessage.getMapStringStringMap(), [
['a', '']
]);
checkMapEquals(deserializedMessage.getMapStringInt32Map(), [
['b', 0]
]);
checkMapEquals(deserializedMessage.getMapStringInt64Map(), [
['c', 0]
]);
checkMapEquals(deserializedMessage.getMapStringBoolMap(), [
['d', false]
]);
checkMapEquals(deserializedMessage.getMapStringDoubleMap(), [
['e', 0.0]
]);
checkMapEquals(deserializedMessage.getMapStringEnumMap(), [
['f', 0]
]);
checkMapEquals(deserializedMessage.getMapStringMsgMap(), [
['g', []]
]);
});
}

10
js/message.js
View File

@ -1860,7 +1860,6 @@ jspb.Message.clone_ = function(obj) {
* @param {Function} constructor The message constructor.
*/
jspb.Message.registerMessageType = function(id, constructor) {
jspb.Message.registry_[id] = constructor;
// This is needed so we can later access messageId directly on the contructor,
// otherwise it is not available due to 'property collapsing' by the compiler.
/**
@ -1868,15 +1867,6 @@ jspb.Message.registerMessageType = function(id, constructor) {
*/
constructor.messageId = id;
};
/**
* The registry of message ids to message constructors.
* @private
*/
jspb.Message.registry_ = {};
/**
* The extensions registered on MessageSet. This is a map of extension
* field number to field info object. This should be considered as a

10
js/package.json
View File

@ -8,11 +8,11 @@
],
"dependencies": {},
"devDependencies": {
"glob": "~6.0.4",
"google-closure-compiler": "~20190301.0.0",
"google-closure-library": "~20190301.0.0",
"gulp": "~4.0.1",
"jasmine": "~2.4.1"
"glob": "~7.1.4",
"google-closure-compiler": "~20190819.0.0",
"google-closure-library": "~20190819.0.0",
"gulp": "~4.0.2",
"jasmine": "~3.4.0"
},
"scripts": {
"test": "node ./node_modules/gulp/bin/gulp.js test"

50
js/testbinary.proto
View File

@ -232,6 +232,56 @@ message TestMapFieldsOptionalKeys {
// End mock-map entries
// These proto are 'mock map' entries to test the above map deserializing with
// undefined values. Make sure TestMapFieldsOptionalValues is written to be
// deserialized by TestMapFields
message MapEntryOptionalValuesStringValue {
optional string key = 1;
optional string value = 2;
}
message MapEntryOptionalValuesInt32Value {
optional string key = 1;
optional int32 value = 2;
}
message MapEntryOptionalValuesInt64Value {
optional string key = 1;
optional int64 value = 2;
}
message MapEntryOptionalValuesBoolValue {
optional string key = 1;
optional bool value = 2;
}
message MapEntryOptionalValuesDoubleValue {
optional string key = 1;
optional double value = 2;
}
message MapEntryOptionalValuesEnumValue {
optional string key = 1;
optional MapValueEnum value = 2;
}
message MapEntryOptionalValuesMessageValue {
optional string key = 1;
optional MapValueMessage value = 2;
}
message TestMapFieldsOptionalValues {
optional MapEntryOptionalValuesStringValue map_string_string = 1;
optional MapEntryOptionalValuesInt32Value map_string_int32 = 2;
optional MapEntryOptionalValuesInt64Value map_string_int64 = 3;
optional MapEntryOptionalValuesBoolValue map_string_bool = 4;
optional MapEntryOptionalValuesDoubleValue map_string_double = 5;
optional MapEntryOptionalValuesEnumValue map_string_enum = 6;
optional MapEntryOptionalValuesMessageValue map_string_msg = 7;
}
// End mock-map entries
enum MapValueEnum {
MAP_VALUE_FOO = 0;
MAP_VALUE_BAR = 1;

49
python/google/protobuf/descriptor_pool.py
View File

@ -68,6 +68,22 @@ from google.protobuf import text_encoding
_USE_C_DESCRIPTORS = descriptor._USE_C_DESCRIPTORS # pylint: disable=protected-access
def _Deprecated(func):
"""Mark functions as deprecated."""
def NewFunc(*args, **kwargs):
warnings.warn(
'Call to deprecated function %s(). Note: Do add unlinked descriptors '
'to descriptor_pool is wrong. Use Add() or AddSerializedFile() '
'instead.' % func.__name__,
category=DeprecationWarning)
return func(*args, **kwargs)
NewFunc.__name__ = func.__name__
NewFunc.__doc__ = func.__doc__
NewFunc.__dict__.update(func.__dict__)
return NewFunc
def _NormalizeFullyQualifiedName(name):
"""Remove leading period from fully-qualified type name.
@ -199,7 +215,14 @@ class DescriptorPool(object):
serialized_file_desc_proto)
self.Add(file_desc_proto)
# Add Descriptor to descriptor pool is dreprecated. Please use Add()
# or AddSerializedFile() to add a FileDescriptorProto instead.
@_Deprecated
def AddDescriptor(self, desc):
self._AddDescriptor(desc)
# Never call this method. It is for internal usage only.
def _AddDescriptor(self, desc):
"""Adds a Descriptor to the pool, non-recursively.
If the Descriptor contains nested messages or enums, the caller must
@ -217,7 +240,14 @@ class DescriptorPool(object):
self._descriptors[desc.full_name] = desc
self._AddFileDescriptor(desc.file)
# Add EnumDescriptor to descriptor pool is dreprecated. Please use Add()
# or AddSerializedFile() to add a FileDescriptorProto instead.
@_Deprecated
def AddEnumDescriptor(self, enum_desc):
self._AddEnumDescriptor(enum_desc)
# Never call this method. It is for internal usage only.
def _AddEnumDescriptor(self, enum_desc):
"""Adds an EnumDescriptor to the pool.
This method also registers the FileDescriptor associated with the enum.
@ -251,7 +281,14 @@ class DescriptorPool(object):
self._top_enum_values[full_name] = enum_value
self._AddFileDescriptor(enum_desc.file)
# Add ServiceDescriptor to descriptor pool is dreprecated. Please use Add()
# or AddSerializedFile() to add a FileDescriptorProto instead.
@_Deprecated
def AddServiceDescriptor(self, service_desc):
self._AddServiceDescriptor(service_desc)
# Never call this method. It is for internal usage only.
def _AddServiceDescriptor(self, service_desc):
"""Adds a ServiceDescriptor to the pool.
Args:
@ -265,7 +302,14 @@ class DescriptorPool(object):
service_desc.file.name)
self._service_descriptors[service_desc.full_name] = service_desc
# Add ExtensionDescriptor to descriptor pool is dreprecated. Please use Add()
# or AddSerializedFile() to add a FileDescriptorProto instead.
@_Deprecated
def AddExtensionDescriptor(self, extension):
self._AddExtensionDescriptor(extension)
# Never call this method. It is for internal usage only.
def _AddExtensionDescriptor(self, extension):
"""Adds a FieldDescriptor describing an extension to the pool.
Args:
@ -307,7 +351,12 @@ class DescriptorPool(object):
self._extensions_by_name[extension.containing_type][
extension.message_type.full_name] = extension
@_Deprecated
def AddFileDescriptor(self, file_desc):
self._InternalAddFileDescriptor(file_desc)
# Never call this method. It is for internal usage only.
def _InternalAddFileDescriptor(self, file_desc):
"""Adds a FileDescriptor to the pool, non-recursively.
If the FileDescriptor contains messages or enums, the caller must explicitly

22
python/google/protobuf/internal/decoder.py
View File

@ -421,12 +421,19 @@ def EnumDecoder(field_number, is_repeated, is_packed, key, new_default):
message._unknown_fields.append(
(tag_bytes, buffer[value_start_pos:pos].tobytes()))
if message._unknown_field_set is None:
message._unknown_field_set = containers.UnknownFieldSet()
message._unknown_field_set._add(
field_number, wire_format.WIRETYPE_VARINT, element)
# pylint: enable=protected-access
if pos > endpoint:
if element in enum_type.values_by_number:
del value[-1] # Discard corrupt value.
else:
del message._unknown_fields[-1]
# pylint: disable=protected-access
del message._unknown_field_set._values[-1]
# pylint: enable=protected-access
raise _DecodeError('Packed element was truncated.')
return pos
return DecodePackedField
@ -459,7 +466,11 @@ def EnumDecoder(field_number, is_repeated, is_packed, key, new_default):
message._unknown_fields = []
message._unknown_fields.append(
(tag_bytes, buffer[pos:new_pos].tobytes()))
# pylint: enable=protected-access
if message._unknown_field_set is None:
message._unknown_field_set = containers.UnknownFieldSet()
message._unknown_field_set._add(
field_number, wire_format.WIRETYPE_VARINT, element)
# pylint: enable=protected-access
# Predict that the next tag is another copy of the same repeated
# field.
pos = new_pos + tag_len
@ -497,6 +508,10 @@ def EnumDecoder(field_number, is_repeated, is_packed, key, new_default):
wire_format.WIRETYPE_VARINT)
message._unknown_fields.append(
(tag_bytes, buffer[value_start_pos:pos].tobytes()))
if message._unknown_field_set is None:
message._unknown_field_set = containers.UnknownFieldSet()
message._unknown_field_set._add(
field_number, wire_format.WIRETYPE_VARINT, enum_value)
# pylint: enable=protected-access
return pos
return DecodeField
@ -812,6 +827,11 @@ def MessageSetItemDecoder(descriptor):
message._unknown_fields = []
message._unknown_fields.append(
(MESSAGE_SET_ITEM_TAG, buffer[message_set_item_start:pos].tobytes()))
if message._unknown_field_set is None:
message._unknown_field_set = containers.UnknownFieldSet()
message._unknown_field_set._add(type_id,
wire_format.WIRETYPE_LENGTH_DELIMITED,
buffer[message_start:message_end])
# pylint: enable=protected-access
return pos

3
python/google/protobuf/internal/descriptor_test.py
View File

@ -655,7 +655,8 @@ class GeneratedDescriptorTest(unittest.TestCase):
nested_message_descriptor = unittest_pb2.TestAllTypes.NestedMessage.DESCRIPTOR
self.assertEqual(len(message_descriptor.nested_types), 3)
self.assertFalse(None in message_descriptor.nested_types)
self.assertTrue(nested_message_descriptor in message_descriptor.nested_types)
self.assertTrue(
nested_message_descriptor in message_descriptor.nested_types)
def testServiceDescriptor(self):
service_descriptor = unittest_pb2.DESCRIPTOR.services_by_name['TestService']

3
python/google/protobuf/internal/extension_dict.py
View File

@ -162,6 +162,9 @@ class _ExtensionDict(object):
type_checker.CheckValue(value))
self._extended_message._Modified()
def __delitem__(self, extension_handle):
self._extended_message.ClearExtension(extension_handle)
def _FindExtensionByName(self, name):
"""Tries to find a known extension with the specified name.

5
python/google/protobuf/internal/python_message.py
View File

@ -676,7 +676,6 @@ def _AddPropertiesForNonRepeatedScalarField(field, cls):
property_name = _PropertyName(proto_field_name)
type_checker = type_checkers.GetTypeChecker(field)
default_value = field.default_value
valid_values = set()
is_proto3 = field.containing_type.syntax == 'proto3'
def getter(self):
@ -785,7 +784,8 @@ def _AddStaticMethods(cls):
def RegisterExtension(extension_handle):
extension_handle.containing_type = cls.DESCRIPTOR
# TODO(amauryfa): Use cls.MESSAGE_FACTORY.pool when available.
cls.DESCRIPTOR.file.pool.AddExtensionDescriptor(extension_handle)
# pylint: disable=protected-access
cls.DESCRIPTOR.file.pool._AddExtensionDescriptor(extension_handle)
_AttachFieldHelpers(cls, extension_handle)
cls.RegisterExtension = staticmethod(RegisterExtension)
@ -1072,7 +1072,6 @@ def _AddSerializeToStringMethod(message_descriptor, cls):
def SerializeToString(self, **kwargs):
# Check if the message has all of its required fields set.
errors = []
if not self.IsInitialized():
raise message_mod.EncodeError(
'Message %s is missing required fields: %s' % (

39
python/google/protobuf/internal/reflection_test.py
View File

@ -506,6 +506,11 @@ class ReflectionTest(unittest.TestCase):
(unittest_pb2.optional_fixed32_extension, 1),
(unittest_pb2.optional_string_extension , 'foo') ],
proto.ListFields())
del proto.Extensions[unittest_pb2.optional_fixed32_extension]
self.assertEqual(
[(unittest_pb2.optional_int32_extension, 5),
(unittest_pb2.optional_string_extension, 'foo')],
proto.ListFields())
def testRepeatedListExtensions(self):
proto = unittest_pb2.TestAllExtensions()
@ -522,6 +527,12 @@ class ReflectionTest(unittest.TestCase):
(unittest_pb2.repeated_fixed32_extension, [1]),
(unittest_pb2.repeated_string_extension , ['foo', 'bar', 'baz']) ],
proto.ListFields())
del proto.Extensions[unittest_pb2.repeated_int32_extension]
del proto.Extensions[unittest_pb2.repeated_string_extension]
self.assertEqual(
[(unittest_pb2.optional_int32_extension, 21),
(unittest_pb2.repeated_fixed32_extension, [1])],
proto.ListFields())
def testListFieldsAndExtensions(self):
proto = unittest_pb2.TestFieldOrderings()
@ -583,6 +594,7 @@ class ReflectionTest(unittest.TestCase):
def testClearFieldWithUnknownFieldName(self):
proto = unittest_pb2.TestAllTypes()
self.assertRaises(ValueError, proto.ClearField, 'nonexistent_field')
self.assertRaises(ValueError, proto.ClearField, b'nonexistent_field')
def testClearRemovesChildren(self):
# Make sure there aren't any implementation bugs that are only partially
@ -1199,6 +1211,32 @@ class ReflectionTest(unittest.TestCase):
self.assertEqual(prius.price, new_prius.price)
self.assertEqual(prius.owners, new_prius.owners)
def testExtensionDelete(self):
extendee_proto = more_extensions_pb2.ExtendedMessage()
extension_int32 = more_extensions_pb2.optional_int_extension
extendee_proto.Extensions[extension_int32] = 23
extension_repeated = more_extensions_pb2.repeated_int_extension
extendee_proto.Extensions[extension_repeated].append(11)
extension_msg = more_extensions_pb2.optional_message_extension
extendee_proto.Extensions[extension_msg].foreign_message_int = 56
self.assertEqual(len(extendee_proto.Extensions), 3)
del extendee_proto.Extensions[extension_msg]
self.assertEqual(len(extendee_proto.Extensions), 2)
del extendee_proto.Extensions[extension_repeated]
self.assertEqual(len(extendee_proto.Extensions), 1)
# Delete a none exist extension. It is OK to "del m.Extensions[ext]"
# even if the extension is not present in the message; we don't
# raise KeyError. This is consistent with "m.Extensions[ext]"
# returning a default value even if we did not set anything.
del extendee_proto.Extensions[extension_repeated]
self.assertEqual(len(extendee_proto.Extensions), 1)
del extendee_proto.Extensions[extension_int32]
self.assertEqual(len(extendee_proto.Extensions), 0)
def testExtensionIter(self):
extendee_proto = more_extensions_pb2.ExtendedMessage()
@ -1820,6 +1858,7 @@ class ReflectionTest(unittest.TestCase):
proto = unittest_pb2.TestRequired()
self.assertFalse(proto.IsInitialized(errors))
self.assertEqual(errors, ['a', 'b', 'c'])
self.assertRaises(TypeError, proto.IsInitialized, 1, 2, 3)
@unittest.skipIf(
api_implementation.Type() != 'cpp' or api_implementation.Version() != 2,

21
python/google/protobuf/internal/text_format_test.py
View File

@ -845,17 +845,18 @@ class OnlyWorksWithProto2RightNowTests(TextFormatBase):
all_data = message.SerializeToString()
empty_message = unittest_pb2.TestEmptyMessage()
empty_message.ParseFromString(all_data)
self.assertEqual('1: 101\n'
'12: 4636878028842991616\n'
'14: "hello"\n'
'15: "103"\n'
'16 {\n'
' 17: 104\n'
'}\n'
'18 {\n'
' 1: 105\n'
'}\n',
self.assertEqual(' 1: 101\n'
' 12: 4636878028842991616\n'
' 14: "hello"\n'
' 15: "103"\n'
' 16 {\n'
' 17: 104\n'
' }\n'
' 18 {\n'
' 1: 105\n'
' }\n',
text_format.MessageToString(empty_message,
indent=2,
print_unknown_fields=True))
self.assertEqual('1: 101 '
'12: 4636878028842991616 '

25
python/google/protobuf/internal/unknown_fields_test.py
View File

@ -50,6 +50,7 @@ from google.protobuf.internal import missing_enum_values_pb2
from google.protobuf.internal import test_util
from google.protobuf.internal import testing_refleaks
from google.protobuf.internal import type_checkers
from google.protobuf.internal import wire_format
from google.protobuf import descriptor
@ -91,7 +92,7 @@ class UnknownFieldsTest(unittest.TestCase):
# Add an unknown extension.
item = raw.item.add()
item.type_id = 98418603
item.type_id = 98218603
message1 = message_set_extensions_pb2.TestMessageSetExtension1()
message1.i = 12345
item.message = message1.SerializeToString()
@ -102,6 +103,19 @@ class UnknownFieldsTest(unittest.TestCase):
proto = message_set_extensions_pb2.TestMessageSet()
proto.MergeFromString(serialized)
unknown_fields = proto.UnknownFields()
self.assertEqual(len(unknown_fields), 1)
# Unknown field should have wire format data which can be parsed back to
# original message.
self.assertEqual(unknown_fields[0].field_number, item.type_id)
self.assertEqual(unknown_fields[0].wire_type,
wire_format.WIRETYPE_LENGTH_DELIMITED)
d = unknown_fields[0].data
message_new = message_set_extensions_pb2.TestMessageSetExtension1()
message_new.ParseFromString(d.tobytes() if isinstance(d, (
memoryview)) else d)
self.assertEqual(message1, message_new)
# Verify that the unknown extension is serialized unchanged
reserialized = proto.SerializeToString()
new_raw = unittest_mset_pb2.RawMessageSet()
@ -344,6 +358,7 @@ class UnknownFieldsAccessorsTest(unittest.TestCase):
def testUnknownExtensions(self):
message = unittest_pb2.TestEmptyMessageWithExtensions()
message.ParseFromString(self.all_fields_data)
self.assertEqual(len(message.UnknownFields()), 97)
self.assertEqual(message.SerializeToString(), self.all_fields_data)
@ -378,12 +393,18 @@ class UnknownEnumValuesTest(unittest.TestCase):
def CheckUnknownField(self, name, expected_value):
field_descriptor = self.descriptor.fields_by_name[name]
unknown_fields = self.missing_message.UnknownFields()
count = 0
for field in unknown_fields:
if field.field_number == field_descriptor.number:
count += 1
if field_descriptor.label == descriptor.FieldDescriptor.LABEL_REPEATED:
self.assertIn(field.data, expected_value)
else:
self.assertEqual(expected_value, field.data)
if field_descriptor.label == descriptor.FieldDescriptor.LABEL_REPEATED:
self.assertEqual(count, len(expected_value))
else:
self.assertEqual(count, 1)
def testUnknownParseMismatchEnumValue(self):
just_string = missing_enum_values_pb2.JustString()
@ -413,6 +434,8 @@ class UnknownEnumValuesTest(unittest.TestCase):
self.assertEqual([], self.missing_message.packed_nested_enum)
def testCheckUnknownFieldValueForEnum(self):
unknown_fields = self.missing_message.UnknownFields()
self.assertEqual(len(unknown_fields), 5)
self.CheckUnknownField('optional_nested_enum',
self.message.optional_nested_enum)
self.CheckUnknownField('repeated_nested_enum',

4
python/google/protobuf/pyext/extension_dict.cc
View File

@ -214,6 +214,10 @@ int ass_subscript(ExtensionDict* self, PyObject* key, PyObject* value) {
return -1;
}
if (value == nullptr) {
return cmessage::ClearFieldByDescriptor(self->parent, descriptor);
}
if (descriptor->label() != FieldDescriptor::LABEL_OPTIONAL ||
descriptor->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE) {
PyErr_SetString(PyExc_TypeError, "Extension is repeated and/or composite "

127
python/google/protobuf/pyext/message.cc
View File

@ -66,7 +66,6 @@
#include <google/protobuf/pyext/scoped_pyobject_ptr.h>
#include <google/protobuf/pyext/unknown_fields.h>
#include <google/protobuf/util/message_differencer.h>
#include <google/protobuf/stubs/strutil.h>
#include <google/protobuf/io/strtod.h>
#include <google/protobuf/stubs/map_util.h>
@ -1332,7 +1331,7 @@ static void Dealloc(CMessage* self) {
PyObject* IsInitialized(CMessage* self, PyObject* args) {
PyObject* errors = NULL;
if (PyArg_ParseTuple(args, "|O", &errors) < 0) {
if (!PyArg_ParseTuple(args, "|O", &errors)) {
return NULL;
}
if (self->message->IsInitialized()) {
@ -1360,20 +1359,18 @@ PyObject* IsInitialized(CMessage* self, PyObject* args) {
Py_RETURN_FALSE;
}
PyObject* HasFieldByDescriptor(
CMessage* self, const FieldDescriptor* field_descriptor) {
int HasFieldByDescriptor(CMessage* self,
const FieldDescriptor* field_descriptor) {
Message* message = self->message;
if (!CheckFieldBelongsToMessage(field_descriptor, message)) {
return NULL;
return -1;
}
if (field_descriptor->label() == FieldDescriptor::LABEL_REPEATED) {
PyErr_SetString(PyExc_KeyError,
"Field is repeated. A singular method is required.");
return NULL;
return -1;
}
bool has_field =
message->GetReflection()->HasField(*message, field_descriptor);
return PyBool_FromLong(has_field ? 1 : 0);
return message->GetReflection()->HasField(*message, field_descriptor);
}
const FieldDescriptor* FindFieldWithOneofs(
@ -1475,10 +1472,10 @@ PyObject* ClearExtension(CMessage* self, PyObject* extension) {
if (descriptor == NULL) {
return NULL;
}
if (InternalReleaseFieldByDescriptor(self, descriptor) < 0) {
return NULL;
if (ClearFieldByDescriptor(self, descriptor) < 0) {
return nullptr;
}
return ClearFieldByDescriptor(self, descriptor);
Py_RETURN_NONE;
}
PyObject* HasExtension(CMessage* self, PyObject* extension) {
@ -1486,7 +1483,12 @@ PyObject* HasExtension(CMessage* self, PyObject* extension) {
if (descriptor == NULL) {
return NULL;
}
return HasFieldByDescriptor(self, descriptor);
int has_field = HasFieldByDescriptor(self, descriptor);
if (has_field < 0) {
return nullptr;
} else {
return PyBool_FromLong(has_field);
}
}
// ---------------------------------------------------------------------
@ -1597,57 +1599,45 @@ int InternalReleaseFieldByDescriptor(
containers_to_release);
}
PyObject* ClearFieldByDescriptor(
CMessage* self,
const FieldDescriptor* field_descriptor) {
int ClearFieldByDescriptor(CMessage* self,
const FieldDescriptor* field_descriptor) {
if (!CheckFieldBelongsToMessage(field_descriptor, self->message)) {
return NULL;
return -1;
}
if (InternalReleaseFieldByDescriptor(self, field_descriptor) < 0) {
return -1;
}
AssureWritable(self);
Message* message = self->message;
message->GetReflection()->ClearField(message, field_descriptor);
Py_RETURN_NONE;
return 0;
}
PyObject* ClearField(CMessage* self, PyObject* arg) {
if (!(PyString_Check(arg) || PyUnicode_Check(arg))) {
PyErr_SetString(PyExc_TypeError, "field name must be a string");
return NULL;
}
#if PY_MAJOR_VERSION < 3
char* field_name;
Py_ssize_t size;
if (PyString_AsStringAndSize(arg, &field_name, &size) < 0) {
Py_ssize_t field_size;
if (PyString_AsStringAndSize(arg, &field_name, &field_size) < 0) {
return NULL;
}
#else
Py_ssize_t size;
const char* field_name = PyUnicode_AsUTF8AndSize(arg, &size);
#endif
AssureWritable(self);
Message* message = self->message;
ScopedPyObjectPtr arg_in_oneof;
bool is_in_oneof;
const FieldDescriptor* field_descriptor =
FindFieldWithOneofs(message, string(field_name, size), &is_in_oneof);
const FieldDescriptor* field_descriptor = FindFieldWithOneofs(
self->message, string(field_name, field_size), &is_in_oneof);
if (field_descriptor == NULL) {
if (!is_in_oneof) {
if (is_in_oneof) {
// We gave the name of a oneof, and none of its fields are set.
Py_RETURN_NONE;
} else {
PyErr_Format(PyExc_ValueError,
"Protocol message has no \"%s\" field.", field_name);
return NULL;
} else {
Py_RETURN_NONE;
}
} else if (is_in_oneof) {
const string& name = field_descriptor->name();
arg_in_oneof.reset(PyString_FromStringAndSize(name.c_str(), name.size()));
arg = arg_in_oneof.get();
}
if (InternalReleaseFieldByDescriptor(self, field_descriptor) < 0) {
return NULL;
if (ClearFieldByDescriptor(self, field_descriptor) < 0) {
return nullptr;
}
return ClearFieldByDescriptor(self, field_descriptor);
Py_RETURN_NONE;
}
PyObject* Clear(CMessage* self) {
@ -1750,6 +1740,15 @@ static PyObject* InternalSerializeToString(
if (size == 0) {
return PyBytes_FromString("");
}
if (size > INT_MAX) {
PyErr_Format(PyExc_ValueError,
"Message %s exceeds maximum protobuf "
"size of 2GB: %zu",
GetMessageName(self).c_str(), size);
return nullptr;
}
PyObject* result = PyBytes_FromStringAndSize(NULL, size);
if (result == NULL) {
return NULL;
@ -1935,32 +1934,42 @@ static PyObject* MergeFromString(CMessage* self, PyObject* arg) {
AssureWritable(self);
io::CodedInputStream input(
reinterpret_cast<const uint8*>(data), data_length);
if (allow_oversize_protos) {
input.SetTotalBytesLimit(INT_MAX, INT_MAX);
input.SetRecursionLimit(INT_MAX);
}
PyMessageFactory* factory = GetFactoryForMessage(self);
input.SetExtensionRegistry(factory->pool->pool, factory->message_factory);
bool success = self->message->MergePartialFromCodedStream(&input);
int depth = allow_oversize_protos
? INT_MAX
: io::CodedInputStream::GetDefaultRecursionLimit();
const char* ptr;
internal::ParseContext ctx(
depth, false, &ptr,
StringPiece(static_cast<const char*>(data), data_length));
ctx.data().pool = factory->pool->pool;
ctx.data().factory = factory->message_factory;
ptr = self->message->_InternalParse(ptr, &ctx);
// Child message might be lazily created before MergeFrom. Make sure they
// are mutable at this point if child messages are really created.
if (FixupMessageAfterMerge(self) < 0) {
return NULL;
}
if (success) {
if (!input.ConsumedEntireMessage()) {
// TODO(jieluo): Raise error and return NULL instead.
// b/27494216
PyErr_Warn(NULL, "Unexpected end-group tag: Not all data was converted");
}
return PyInt_FromLong(input.CurrentPosition());
} else {
// Python makes distinction in error message, between a general parse failure
// and in-correct ending on a terminating tag. Hence we need to be a bit more
// explicit in our correctness checks.
if (ptr == nullptr || ctx.BytesUntilLimit(ptr) < 0) {
// Parse error or the parser overshoot the limit.
PyErr_Format(DecodeError_class, "Error parsing message");
return NULL;
}
// ctx has an explicit limit set (length of string_view), so we have to
// check we ended at that limit.
if (!ctx.EndedAtLimit()) {
// TODO(jieluo): Raise error and return NULL instead.
// b/27494216
PyErr_Warn(nullptr, "Unexpected end-group tag: Not all data was converted");
return PyInt_FromLong(data_length - ctx.BytesUntilLimit(ptr));
}
return PyInt_FromLong(data_length);
}
static PyObject* ParseFromString(CMessage* self, PyObject* arg) {

21
python/google/protobuf/pyext/message.h
View File

@ -224,28 +224,19 @@ bool SetSubmessage(CMessage* self, CMessage* submessage);
// Corresponds to message api method Clear.
PyObject* Clear(CMessage* self);
// Clears the data described by the given descriptor. Used to clear extensions
// (which don't have names). Extension release is handled by ExtensionDict
// class, not this function.
// TODO(anuraag): Try to make this discrepancy in release semantics with
// ClearField less confusing.
// Clears the data described by the given descriptor.
// Returns -1 on error.
//
// Corresponds to reflection api method ClearField.
PyObject* ClearFieldByDescriptor(
CMessage* self, const FieldDescriptor* descriptor);
// Clears the data for the given field name. The message is released if there
// are any external references.
//
// Corresponds to reflection api method ClearField.
PyObject* ClearField(CMessage* self, PyObject* arg);
int ClearFieldByDescriptor(CMessage* self, const FieldDescriptor* descriptor);
// Checks if the message has the field described by the descriptor. Used for
// extensions (which have no name).
// Returns 1 if true, 0 if false, and -1 on error.
//
// Corresponds to reflection api method HasField
PyObject* HasFieldByDescriptor(
CMessage* self, const FieldDescriptor* field_descriptor);
int HasFieldByDescriptor(CMessage* self,
const FieldDescriptor* field_descriptor);
// Checks if the message has the named field.
//

17
python/google/protobuf/symbol_database.py
View File

@ -58,6 +58,7 @@ Example usage:
"""
from google.protobuf.internal import api_implementation
from google.protobuf import descriptor_pool
from google.protobuf import message_factory
@ -88,7 +89,9 @@ class SymbolDatabase(message_factory.MessageFactory):
Args:
message_descriptor: a descriptor.MessageDescriptor.
"""
self.pool.AddDescriptor(message_descriptor)
if api_implementation.Type() == 'python':
# pylint: disable=protected-access
self.pool._AddDescriptor(message_descriptor)
def RegisterEnumDescriptor(self, enum_descriptor):
"""Registers the given enum descriptor in the local database.
@ -99,7 +102,9 @@ class SymbolDatabase(message_factory.MessageFactory):
Returns:
The provided descriptor.
"""
self.pool.AddEnumDescriptor(enum_descriptor)
if api_implementation.Type() == 'python':
# pylint: disable=protected-access
self.pool._AddEnumDescriptor(enum_descriptor)
return enum_descriptor
def RegisterServiceDescriptor(self, service_descriptor):
@ -111,7 +116,9 @@ class SymbolDatabase(message_factory.MessageFactory):
Returns:
The provided descriptor.
"""
self.pool.AddServiceDescriptor(service_descriptor)
if api_implementation.Type() == 'python':
# pylint: disable=protected-access
self.pool._AddServiceDescriptor(service_descriptor)
def RegisterFileDescriptor(self, file_descriptor):
"""Registers the given file descriptor in the local database.
@ -122,7 +129,9 @@ class SymbolDatabase(message_factory.MessageFactory):
Returns:
The provided descriptor.
"""
self.pool.AddFileDescriptor(file_descriptor)
if api_implementation.Type() == 'python':
# pylint: disable=protected-access
self.pool._InternalAddFileDescriptor(file_descriptor)
def GetSymbol(self, symbol):
"""Tries to find a symbol in the local database.

7
python/google/protobuf/text_format.py
View File

@ -42,6 +42,9 @@ Simple usage example:
__author__ = 'kenton@google.com (Kenton Varda)'
# TODO(b/129989314) Import thread contention leads to test failures.
import encodings.raw_unicode_escape # pylint: disable=unused-import
import encodings.unicode_escape # pylint: disable=unused-import
import io
import re
@ -455,8 +458,8 @@ class _Printer(object):
if self.as_one_line:
out.write('} ')
else:
out.write('}\n')
self.indent -= 2
out.write(' ' * self.indent + '}\n')
elif field.wire_type == WIRETYPE_LENGTH_DELIMITED:
try:
# If this field is parseable as a Message, it is probably
@ -479,8 +482,8 @@ class _Printer(object):
if self.as_one_line:
out.write('} ')
else:
out.write('}\n')
self.indent -= 2
out.write(' ' * self.indent + '}\n')
else:
# A string or bytes field. self.as_utf8 may not work.
out.write(': \"')

58
src/google/protobuf/any.pb.cc
View File

@ -171,7 +171,6 @@ void Any::Clear() {
_internal_metadata_.Clear();
}
#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* Any::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
while (!ctx->Done(&ptr)) {
@ -212,63 +211,6 @@ failure:
goto success;
#undef CHK_
}
#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool Any::MergePartialFromCodedStream(
::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
::PROTOBUF_NAMESPACE_ID::uint32 tag;
// @@protoc_insertion_point(parse_start:google.protobuf.Any)
for (;;) {
::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
tag = p.first;
if (!p.second) goto handle_unusual;
switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
// string type_url = 1;
case 1: {
if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) {
DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString(
input, this->_internal_mutable_type_url()));
DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
this->_internal_type_url().data(), static_cast<int>(this->_internal_type_url().length()),
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE,
"google.protobuf.Any.type_url"));
} else {
goto handle_unusual;
}
break;
}
// bytes value = 2;
case 2: {
if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) {
DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadBytes(
input, this->_internal_mutable_value()));
} else {
goto handle_unusual;
}
break;
}
default: {
handle_unusual:
if (tag == 0) {
goto success;
}
DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
input, tag, _internal_metadata_.mutable_unknown_fields()));
break;
}
}
}
success:
// @@protoc_insertion_point(parse_success:google.protobuf.Any)
return true;
failure:
// @@protoc_insertion_point(parse_failure:google.protobuf.Any)
return false;
#undef DO_
}
#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
::PROTOBUF_NAMESPACE_ID::uint8* Any::InternalSerializeWithCachedSizesToArray(
::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {

5
src/google/protobuf/any.pb.h
View File

@ -151,12 +151,7 @@ class PROTOBUF_EXPORT Any :
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
#else
bool MergePartialFromCodedStream(
::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }

380
src/google/protobuf/api.pb.cc
View File

@ -215,7 +215,7 @@ Api::Api(const Api& from)
if (!from._internal_version().empty()) {
version_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.version_);
}
if (from.has_source_context()) {
if (from._internal_has_source_context()) {
source_context_ = new PROTOBUF_NAMESPACE_ID::SourceContext(*from.source_context_);
} else {
source_context_ = nullptr;
@ -272,7 +272,6 @@ void Api::Clear() {
_internal_metadata_.Clear();
}
#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* Api::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
while (!ctx->Done(&ptr)) {
@ -293,7 +292,7 @@ const char* Api::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::intern
ptr -= 1;
do {
ptr += 1;
ptr = ctx->ParseMessage(add_methods(), ptr);
ptr = ctx->ParseMessage(_internal_add_methods(), ptr);
CHK_(ptr);
if (!ctx->DataAvailable(ptr)) break;
} while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
@ -305,7 +304,7 @@ const char* Api::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::intern
ptr -= 1;
do {
ptr += 1;
ptr = ctx->ParseMessage(add_options(), ptr);
ptr = ctx->ParseMessage(_internal_add_options(), ptr);
CHK_(ptr);
if (!ctx->DataAvailable(ptr)) break;
} while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr));
@ -321,7 +320,7 @@ const char* Api::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::intern
// .google.protobuf.SourceContext source_context = 5;
case 5:
if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) {
ptr = ctx->ParseMessage(mutable_source_context(), ptr);
ptr = ctx->ParseMessage(_internal_mutable_source_context(), ptr);
CHK_(ptr);
} else goto handle_unusual;
continue;
@ -331,7 +330,7 @@ const char* Api::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::intern
ptr -= 1;
do {
ptr += 1;
ptr = ctx->ParseMessage(add_mixins(), ptr);
ptr = ctx->ParseMessage(_internal_add_mixins(), ptr);
CHK_(ptr);
if (!ctx->DataAvailable(ptr)) break;
} while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<50>(ptr));
@ -342,7 +341,7 @@ const char* Api::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::intern
if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 56)) {
::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
CHK_(ptr);
set_syntax(static_cast<PROTOBUF_NAMESPACE_ID::Syntax>(val));
_internal_set_syntax(static_cast<PROTOBUF_NAMESPACE_ID::Syntax>(val));
} else goto handle_unusual;
continue;
default: {
@ -364,125 +363,6 @@ failure:
goto success;
#undef CHK_
}
#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool Api::MergePartialFromCodedStream(
::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
::PROTOBUF_NAMESPACE_ID::uint32 tag;
// @@protoc_insertion_point(parse_start:google.protobuf.Api)
for (;;) {
::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
tag = p.first;
if (!p.second) goto handle_unusual;
switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
// string name = 1;
case 1: {
if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) {
DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString(
input, this->_internal_mutable_name()));
DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
this->_internal_name().data(), static_cast<int>(this->_internal_name().length()),
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE,
"google.protobuf.Api.name"));
} else {
goto handle_unusual;
}
break;
}
// repeated .google.protobuf.Method methods = 2;
case 2: {
if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) {
DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
input, add_methods()));
} else {
goto handle_unusual;
}
break;
}
// repeated .google.protobuf.Option options = 3;
case 3: {
if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (26 & 0xFF)) {
DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
input, add_options()));
} else {
goto handle_unusual;
}
break;
}
// string version = 4;
case 4: {
if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (34 & 0xFF)) {
DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString(
input, this->_internal_mutable_version()));
DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
this->_internal_version().data(), static_cast<int>(this->_internal_version().length()),
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE,
"google.protobuf.Api.version"));
} else {
goto handle_unusual;
}
break;
}
// .google.protobuf.SourceContext source_context = 5;
case 5: {
if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (42 & 0xFF)) {
DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
input, mutable_source_context()));
} else {
goto handle_unusual;
}
break;
}
// repeated .google.protobuf.Mixin mixins = 6;
case 6: {
if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (50 & 0xFF)) {
DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
input, add_mixins()));
} else {
goto handle_unusual;
}
break;
}
// .google.protobuf.Syntax syntax = 7;
case 7: {
if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (56 & 0xFF)) {
int value = 0;
DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
int, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_ENUM>(
input, &value)));
set_syntax(static_cast< PROTOBUF_NAMESPACE_ID::Syntax >(value));
} else {
goto handle_unusual;
}
break;
}
default: {
handle_unusual:
if (tag == 0) {
goto success;
}
DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
input, tag, _internal_metadata_.mutable_unknown_fields()));
break;
}
}
}
success:
// @@protoc_insertion_point(parse_success:google.protobuf.Api)
return true;
failure:
// @@protoc_insertion_point(parse_failure:google.protobuf.Api)
return false;
#undef DO_
}
#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
::PROTOBUF_NAMESPACE_ID::uint8* Api::InternalSerializeWithCachedSizesToArray(
::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
@ -501,19 +381,19 @@ failure:
}
// repeated .google.protobuf.Method methods = 2;
for (auto it = this->methods_.pointer_begin(),
end = this->methods_.pointer_end(); it < end; ++it) {
for (unsigned int i = 0,
n = static_cast<unsigned int>(this->_internal_methods_size()); i < n; i++) {
stream->EnsureSpace(&target);
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
InternalWriteMessageToArray(2, **it, target, stream);
InternalWriteMessageToArray(2, this->_internal_methods(i), target, stream);
}
// repeated .google.protobuf.Option options = 3;
for (auto it = this->options_.pointer_begin(),
end = this->options_.pointer_end(); it < end; ++it) {
for (unsigned int i = 0,
n = static_cast<unsigned int>(this->_internal_options_size()); i < n; i++) {
stream->EnsureSpace(&target);
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
InternalWriteMessageToArray(3, **it, target, stream);
InternalWriteMessageToArray(3, this->_internal_options(i), target, stream);
}
// string version = 4;
@ -535,18 +415,18 @@ failure:
}
// repeated .google.protobuf.Mixin mixins = 6;
for (auto it = this->mixins_.pointer_begin(),
end = this->mixins_.pointer_end(); it < end; ++it) {
for (unsigned int i = 0,
n = static_cast<unsigned int>(this->_internal_mixins_size()); i < n; i++) {
stream->EnsureSpace(&target);
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
InternalWriteMessageToArray(6, **it, target, stream);
InternalWriteMessageToArray(6, this->_internal_mixins(i), target, stream);
}
// .google.protobuf.Syntax syntax = 7;
if (this->syntax() != 0) {
stream->EnsureSpace(&target);
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
7, this->syntax(), target);
7, this->_internal_syntax(), target);
}
if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
@ -566,21 +446,21 @@ size_t Api::ByteSizeLong() const {
(void) cached_has_bits;
// repeated .google.protobuf.Method methods = 2;
total_size += 1UL * this->methods_size();
total_size += 1UL * this->_internal_methods_size();
for (const auto& msg : this->methods_) {
total_size +=
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
}
// repeated .google.protobuf.Option options = 3;
total_size += 1UL * this->options_size();
total_size += 1UL * this->_internal_options_size();
for (const auto& msg : this->options_) {
total_size +=
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
}
// repeated .google.protobuf.Mixin mixins = 6;
total_size += 1UL * this->mixins_size();
total_size += 1UL * this->_internal_mixins_size();
for (const auto& msg : this->mixins_) {
total_size +=
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
@ -610,7 +490,7 @@ size_t Api::ByteSizeLong() const {
// .google.protobuf.Syntax syntax = 7;
if (this->syntax() != 0) {
total_size += 1 +
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->syntax());
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_syntax());
}
if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
@ -656,10 +536,10 @@ void Api::MergeFrom(const Api& from) {
version_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.version_);
}
if (from.has_source_context()) {
mutable_source_context()->PROTOBUF_NAMESPACE_ID::SourceContext::MergeFrom(from.source_context());
_internal_mutable_source_context()->PROTOBUF_NAMESPACE_ID::SourceContext::MergeFrom(from._internal_source_context());
}
if (from.syntax() != 0) {
set_syntax(from.syntax());
_internal_set_syntax(from._internal_syntax());
}
}
@ -785,7 +665,6 @@ void Method::Clear() {
_internal_metadata_.Clear();
}
#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* Method::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
while (!ctx->Done(&ptr)) {
@ -834,7 +713,7 @@ const char* Method::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::int
ptr -= 1;
do {
ptr += 1;
ptr = ctx->ParseMessage(add_options(), ptr);
ptr = ctx->ParseMessage(_internal_add_options(), ptr);
CHK_(ptr);
if (!ctx->DataAvailable(ptr)) break;
} while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<50>(ptr));
@ -845,7 +724,7 @@ const char* Method::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::int
if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 56)) {
::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
CHK_(ptr);
set_syntax(static_cast<PROTOBUF_NAMESPACE_ID::Syntax>(val));
_internal_set_syntax(static_cast<PROTOBUF_NAMESPACE_ID::Syntax>(val));
} else goto handle_unusual;
continue;
default: {
@ -867,133 +746,6 @@ failure:
goto success;
#undef CHK_
}
#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool Method::MergePartialFromCodedStream(
::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
::PROTOBUF_NAMESPACE_ID::uint32 tag;
// @@protoc_insertion_point(parse_start:google.protobuf.Method)
for (;;) {
::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
tag = p.first;
if (!p.second) goto handle_unusual;
switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
// string name = 1;
case 1: {
if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) {
DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString(
input, this->_internal_mutable_name()));
DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
this->_internal_name().data(), static_cast<int>(this->_internal_name().length()),
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE,
"google.protobuf.Method.name"));
} else {
goto handle_unusual;
}
break;
}
// string request_type_url = 2;
case 2: {
if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) {
DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString(
input, this->_internal_mutable_request_type_url()));
DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
this->_internal_request_type_url().data(), static_cast<int>(this->_internal_request_type_url().length()),
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE,
"google.protobuf.Method.request_type_url"));
} else {
goto handle_unusual;
}
break;
}
// bool request_streaming = 3;
case 3: {
if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (24 & 0xFF)) {
DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
bool, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BOOL>(
input, &request_streaming_)));
} else {
goto handle_unusual;
}
break;
}
// string response_type_url = 4;
case 4: {
if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (34 & 0xFF)) {
DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString(
input, this->_internal_mutable_response_type_url()));
DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
this->_internal_response_type_url().data(), static_cast<int>(this->_internal_response_type_url().length()),
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE,
"google.protobuf.Method.response_type_url"));
} else {
goto handle_unusual;
}
break;
}
// bool response_streaming = 5;
case 5: {
if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (40 & 0xFF)) {
DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
bool, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BOOL>(
input, &response_streaming_)));
} else {
goto handle_unusual;
}
break;
}
// repeated .google.protobuf.Option options = 6;
case 6: {
if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (50 & 0xFF)) {
DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
input, add_options()));
} else {
goto handle_unusual;
}
break;
}
// .google.protobuf.Syntax syntax = 7;
case 7: {
if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (56 & 0xFF)) {
int value = 0;
DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
int, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_ENUM>(
input, &value)));
set_syntax(static_cast< PROTOBUF_NAMESPACE_ID::Syntax >(value));
} else {
goto handle_unusual;
}
break;
}
default: {
handle_unusual:
if (tag == 0) {
goto success;
}
DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
input, tag, _internal_metadata_.mutable_unknown_fields()));
break;
}
}
}
success:
// @@protoc_insertion_point(parse_success:google.protobuf.Method)
return true;
failure:
// @@protoc_insertion_point(parse_failure:google.protobuf.Method)
return false;
#undef DO_
}
#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
::PROTOBUF_NAMESPACE_ID::uint8* Method::InternalSerializeWithCachedSizesToArray(
::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
@ -1024,7 +776,7 @@ failure:
// bool request_streaming = 3;
if (this->request_streaming() != 0) {
stream->EnsureSpace(&target);
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(3, this->request_streaming(), target);
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(3, this->_internal_request_streaming(), target);
}
// string response_type_url = 4;
@ -1040,22 +792,22 @@ failure:
// bool response_streaming = 5;
if (this->response_streaming() != 0) {
stream->EnsureSpace(&target);
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(5, this->response_streaming(), target);
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(5, this->_internal_response_streaming(), target);
}
// repeated .google.protobuf.Option options = 6;
for (auto it = this->options_.pointer_begin(),
end = this->options_.pointer_end(); it < end; ++it) {
for (unsigned int i = 0,
n = static_cast<unsigned int>(this->_internal_options_size()); i < n; i++) {
stream->EnsureSpace(&target);
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
InternalWriteMessageToArray(6, **it, target, stream);
InternalWriteMessageToArray(6, this->_internal_options(i), target, stream);
}
// .google.protobuf.Syntax syntax = 7;
if (this->syntax() != 0) {
stream->EnsureSpace(&target);
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
7, this->syntax(), target);
7, this->_internal_syntax(), target);
}
if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
@ -1075,7 +827,7 @@ size_t Method::ByteSizeLong() const {
(void) cached_has_bits;
// repeated .google.protobuf.Option options = 6;
total_size += 1UL * this->options_size();
total_size += 1UL * this->_internal_options_size();
for (const auto& msg : this->options_) {
total_size +=
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
@ -1115,7 +867,7 @@ size_t Method::ByteSizeLong() const {
// .google.protobuf.Syntax syntax = 7;
if (this->syntax() != 0) {
total_size += 1 +
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->syntax());
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_syntax());
}
if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
@ -1163,13 +915,13 @@ void Method::MergeFrom(const Method& from) {
response_type_url_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.response_type_url_);
}
if (from.request_streaming() != 0) {
set_request_streaming(from.request_streaming());
_internal_set_request_streaming(from._internal_request_streaming());
}
if (from.response_streaming() != 0) {
set_response_streaming(from.response_streaming());
_internal_set_response_streaming(from._internal_response_streaming());
}
if (from.syntax() != 0) {
set_syntax(from.syntax());
_internal_set_syntax(from._internal_syntax());
}
}
@ -1275,7 +1027,6 @@ void Mixin::Clear() {
_internal_metadata_.Clear();
}
#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* Mixin::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
while (!ctx->Done(&ptr)) {
@ -1316,67 +1067,6 @@ failure:
goto success;
#undef CHK_
}
#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool Mixin::MergePartialFromCodedStream(
::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
::PROTOBUF_NAMESPACE_ID::uint32 tag;
// @@protoc_insertion_point(parse_start:google.protobuf.Mixin)
for (;;) {
::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
tag = p.first;
if (!p.second) goto handle_unusual;
switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
// string name = 1;
case 1: {
if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) {
DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString(
input, this->_internal_mutable_name()));
DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
this->_internal_name().data(), static_cast<int>(this->_internal_name().length()),
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE,
"google.protobuf.Mixin.name"));
} else {
goto handle_unusual;
}
break;
}
// string root = 2;
case 2: {
if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) {
DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString(
input, this->_internal_mutable_root()));
DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
this->_internal_root().data(), static_cast<int>(this->_internal_root().length()),
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE,
"google.protobuf.Mixin.root"));
} else {
goto handle_unusual;
}
break;
}
default: {
handle_unusual:
if (tag == 0) {
goto success;
}
DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
input, tag, _internal_metadata_.mutable_unknown_fields()));
break;
}
}
}
success:
// @@protoc_insertion_point(parse_success:google.protobuf.Mixin)
return true;
failure:
// @@protoc_insertion_point(parse_failure:google.protobuf.Mixin)
return false;
#undef DO_
}
#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
::PROTOBUF_NAMESPACE_ID::uint8* Mixin::InternalSerializeWithCachedSizesToArray(
::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {

190
src/google/protobuf/api.pb.h
View File

@ -145,12 +145,7 @@ class PROTOBUF_EXPORT Api :
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
#else
bool MergePartialFromCodedStream(
::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
@ -197,10 +192,17 @@ class PROTOBUF_EXPORT Api :
};
// repeated .google.protobuf.Method methods = 2;
int methods_size() const;
private:
int _internal_methods_size() const;
public:
void clear_methods();
PROTOBUF_NAMESPACE_ID::Method* mutable_methods(int index);
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::Method >*
mutable_methods();
private:
const PROTOBUF_NAMESPACE_ID::Method& _internal_methods(int index) const;
PROTOBUF_NAMESPACE_ID::Method* _internal_add_methods();
public:
const PROTOBUF_NAMESPACE_ID::Method& methods(int index) const;
PROTOBUF_NAMESPACE_ID::Method* add_methods();
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::Method >&
@ -208,10 +210,17 @@ class PROTOBUF_EXPORT Api :
// repeated .google.protobuf.Option options = 3;
int options_size() const;
private:
int _internal_options_size() const;
public:
void clear_options();
PROTOBUF_NAMESPACE_ID::Option* mutable_options(int index);
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::Option >*
mutable_options();
private:
const PROTOBUF_NAMESPACE_ID::Option& _internal_options(int index) const;
PROTOBUF_NAMESPACE_ID::Option* _internal_add_options();
public:
const PROTOBUF_NAMESPACE_ID::Option& options(int index) const;
PROTOBUF_NAMESPACE_ID::Option* add_options();
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::Option >&
@ -219,10 +228,17 @@ class PROTOBUF_EXPORT Api :
// repeated .google.protobuf.Mixin mixins = 6;
int mixins_size() const;
private:
int _internal_mixins_size() const;
public:
void clear_mixins();
PROTOBUF_NAMESPACE_ID::Mixin* mutable_mixins(int index);
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::Mixin >*
mutable_mixins();
private:
const PROTOBUF_NAMESPACE_ID::Mixin& _internal_mixins(int index) const;
PROTOBUF_NAMESPACE_ID::Mixin* _internal_add_mixins();
public:
const PROTOBUF_NAMESPACE_ID::Mixin& mixins(int index) const;
PROTOBUF_NAMESPACE_ID::Mixin* add_mixins();
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::Mixin >&
@ -270,11 +286,19 @@ class PROTOBUF_EXPORT Api :
PROTOBUF_NAMESPACE_ID::SourceContext* release_source_context();
PROTOBUF_NAMESPACE_ID::SourceContext* mutable_source_context();
void set_allocated_source_context(PROTOBUF_NAMESPACE_ID::SourceContext* source_context);
private:
const PROTOBUF_NAMESPACE_ID::SourceContext& _internal_source_context() const;
PROTOBUF_NAMESPACE_ID::SourceContext* _internal_mutable_source_context();
public:
// .google.protobuf.Syntax syntax = 7;
void clear_syntax();
PROTOBUF_NAMESPACE_ID::Syntax syntax() const;
void set_syntax(PROTOBUF_NAMESPACE_ID::Syntax value);
private:
PROTOBUF_NAMESPACE_ID::Syntax _internal_syntax() const;
void _internal_set_syntax(PROTOBUF_NAMESPACE_ID::Syntax value);
public:
// @@protoc_insertion_point(class_scope:google.protobuf.Api)
private:
@ -362,12 +386,7 @@ class PROTOBUF_EXPORT Method :
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
#else
bool MergePartialFromCodedStream(
::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
@ -414,10 +433,17 @@ class PROTOBUF_EXPORT Method :
};
// repeated .google.protobuf.Option options = 6;
int options_size() const;
private:
int _internal_options_size() const;
public:
void clear_options();
PROTOBUF_NAMESPACE_ID::Option* mutable_options(int index);
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::Option >*
mutable_options();
private:
const PROTOBUF_NAMESPACE_ID::Option& _internal_options(int index) const;
PROTOBUF_NAMESPACE_ID::Option* _internal_add_options();
public:
const PROTOBUF_NAMESPACE_ID::Option& options(int index) const;
PROTOBUF_NAMESPACE_ID::Option* add_options();
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::Option >&
@ -475,16 +501,28 @@ class PROTOBUF_EXPORT Method :
void clear_request_streaming();
bool request_streaming() const;
void set_request_streaming(bool value);
private:
bool _internal_request_streaming() const;
void _internal_set_request_streaming(bool value);
public:
// bool response_streaming = 5;
void clear_response_streaming();
bool response_streaming() const;
void set_response_streaming(bool value);
private:
bool _internal_response_streaming() const;
void _internal_set_response_streaming(bool value);
public:
// .google.protobuf.Syntax syntax = 7;
void clear_syntax();
PROTOBUF_NAMESPACE_ID::Syntax syntax() const;
void set_syntax(PROTOBUF_NAMESPACE_ID::Syntax value);
private:
PROTOBUF_NAMESPACE_ID::Syntax _internal_syntax() const;
void _internal_set_syntax(PROTOBUF_NAMESPACE_ID::Syntax value);
public:
// @@protoc_insertion_point(class_scope:google.protobuf.Method)
private:
@ -572,12 +610,7 @@ class PROTOBUF_EXPORT Mixin :
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
#else
bool MergePartialFromCodedStream(
::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
@ -731,9 +764,12 @@ inline void Api::set_allocated_name(std::string* name) {
}
// repeated .google.protobuf.Method methods = 2;
inline int Api::methods_size() const {
inline int Api::_internal_methods_size() const {
return methods_.size();
}
inline int Api::methods_size() const {
return _internal_methods_size();
}
inline void Api::clear_methods() {
methods_.Clear();
}
@ -746,13 +782,19 @@ Api::mutable_methods() {
// @@protoc_insertion_point(field_mutable_list:google.protobuf.Api.methods)
return &methods_;
}
inline const PROTOBUF_NAMESPACE_ID::Method& Api::_internal_methods(int index) const {
return methods_.Get(index);
}
inline const PROTOBUF_NAMESPACE_ID::Method& Api::methods(int index) const {
// @@protoc_insertion_point(field_get:google.protobuf.Api.methods)
return methods_.Get(index);
return _internal_methods(index);
}
inline PROTOBUF_NAMESPACE_ID::Method* Api::_internal_add_methods() {
return methods_.Add();
}
inline PROTOBUF_NAMESPACE_ID::Method* Api::add_methods() {
// @@protoc_insertion_point(field_add:google.protobuf.Api.methods)
return methods_.Add();
return _internal_add_methods();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::Method >&
Api::methods() const {
@ -761,9 +803,12 @@ Api::methods() const {
}
// repeated .google.protobuf.Option options = 3;
inline int Api::options_size() const {
inline int Api::_internal_options_size() const {
return options_.size();
}
inline int Api::options_size() const {
return _internal_options_size();
}
inline PROTOBUF_NAMESPACE_ID::Option* Api::mutable_options(int index) {
// @@protoc_insertion_point(field_mutable:google.protobuf.Api.options)
return options_.Mutable(index);
@ -773,13 +818,19 @@ Api::mutable_options() {
// @@protoc_insertion_point(field_mutable_list:google.protobuf.Api.options)
return &options_;
}
inline const PROTOBUF_NAMESPACE_ID::Option& Api::_internal_options(int index) const {
return options_.Get(index);
}
inline const PROTOBUF_NAMESPACE_ID::Option& Api::options(int index) const {
// @@protoc_insertion_point(field_get:google.protobuf.Api.options)
return options_.Get(index);
return _internal_options(index);
}
inline PROTOBUF_NAMESPACE_ID::Option* Api::_internal_add_options() {
return options_.Add();
}
inline PROTOBUF_NAMESPACE_ID::Option* Api::add_options() {
// @@protoc_insertion_point(field_add:google.protobuf.Api.options)
return options_.Add();
return _internal_add_options();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::Option >&
Api::options() const {
@ -848,15 +899,21 @@ inline void Api::set_allocated_version(std::string* version) {
}
// .google.protobuf.SourceContext source_context = 5;
inline bool Api::has_source_context() const {
inline bool Api::_internal_has_source_context() const {
return this != internal_default_instance() && source_context_ != nullptr;
}
inline const PROTOBUF_NAMESPACE_ID::SourceContext& Api::source_context() const {
inline bool Api::has_source_context() const {
return _internal_has_source_context();
}
inline const PROTOBUF_NAMESPACE_ID::SourceContext& Api::_internal_source_context() const {
const PROTOBUF_NAMESPACE_ID::SourceContext* p = source_context_;
// @@protoc_insertion_point(field_get:google.protobuf.Api.source_context)
return p != nullptr ? *p : *reinterpret_cast<const PROTOBUF_NAMESPACE_ID::SourceContext*>(
&PROTOBUF_NAMESPACE_ID::_SourceContext_default_instance_);
}
inline const PROTOBUF_NAMESPACE_ID::SourceContext& Api::source_context() const {
// @@protoc_insertion_point(field_get:google.protobuf.Api.source_context)
return _internal_source_context();
}
inline PROTOBUF_NAMESPACE_ID::SourceContext* Api::release_source_context() {
// @@protoc_insertion_point(field_release:google.protobuf.Api.source_context)
@ -864,15 +921,18 @@ inline PROTOBUF_NAMESPACE_ID::SourceContext* Api::release_source_context() {
source_context_ = nullptr;
return temp;
}
inline PROTOBUF_NAMESPACE_ID::SourceContext* Api::mutable_source_context() {
inline PROTOBUF_NAMESPACE_ID::SourceContext* Api::_internal_mutable_source_context() {
if (source_context_ == nullptr) {
auto* p = CreateMaybeMessage<PROTOBUF_NAMESPACE_ID::SourceContext>(GetArenaNoVirtual());
source_context_ = p;
}
// @@protoc_insertion_point(field_mutable:google.protobuf.Api.source_context)
return source_context_;
}
inline PROTOBUF_NAMESPACE_ID::SourceContext* Api::mutable_source_context() {
// @@protoc_insertion_point(field_mutable:google.protobuf.Api.source_context)
return _internal_mutable_source_context();
}
inline void Api::set_allocated_source_context(PROTOBUF_NAMESPACE_ID::SourceContext* source_context) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == nullptr) {
@ -893,9 +953,12 @@ inline void Api::set_allocated_source_context(PROTOBUF_NAMESPACE_ID::SourceConte
}
// repeated .google.protobuf.Mixin mixins = 6;
inline int Api::mixins_size() const {
inline int Api::_internal_mixins_size() const {
return mixins_.size();
}
inline int Api::mixins_size() const {
return _internal_mixins_size();
}
inline void Api::clear_mixins() {
mixins_.Clear();
}
@ -908,13 +971,19 @@ Api::mutable_mixins() {
// @@protoc_insertion_point(field_mutable_list:google.protobuf.Api.mixins)
return &mixins_;
}
inline const PROTOBUF_NAMESPACE_ID::Mixin& Api::_internal_mixins(int index) const {
return mixins_.Get(index);
}
inline const PROTOBUF_NAMESPACE_ID::Mixin& Api::mixins(int index) const {
// @@protoc_insertion_point(field_get:google.protobuf.Api.mixins)
return mixins_.Get(index);
return _internal_mixins(index);
}
inline PROTOBUF_NAMESPACE_ID::Mixin* Api::_internal_add_mixins() {
return mixins_.Add();
}
inline PROTOBUF_NAMESPACE_ID::Mixin* Api::add_mixins() {
// @@protoc_insertion_point(field_add:google.protobuf.Api.mixins)
return mixins_.Add();
return _internal_add_mixins();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::Mixin >&
Api::mixins() const {
@ -926,13 +995,19 @@ Api::mixins() const {
inline void Api::clear_syntax() {
syntax_ = 0;
}
inline PROTOBUF_NAMESPACE_ID::Syntax Api::syntax() const {
// @@protoc_insertion_point(field_get:google.protobuf.Api.syntax)
inline PROTOBUF_NAMESPACE_ID::Syntax Api::_internal_syntax() const {
return static_cast< PROTOBUF_NAMESPACE_ID::Syntax >(syntax_);
}
inline void Api::set_syntax(PROTOBUF_NAMESPACE_ID::Syntax value) {
inline PROTOBUF_NAMESPACE_ID::Syntax Api::syntax() const {
// @@protoc_insertion_point(field_get:google.protobuf.Api.syntax)
return _internal_syntax();
}
inline void Api::_internal_set_syntax(PROTOBUF_NAMESPACE_ID::Syntax value) {
syntax_ = value;
}
inline void Api::set_syntax(PROTOBUF_NAMESPACE_ID::Syntax value) {
_internal_set_syntax(value);
// @@protoc_insertion_point(field_set:google.protobuf.Api.syntax)
}
@ -1064,13 +1139,19 @@ inline void Method::set_allocated_request_type_url(std::string* request_type_url
inline void Method::clear_request_streaming() {
request_streaming_ = false;
}
inline bool Method::request_streaming() const {
// @@protoc_insertion_point(field_get:google.protobuf.Method.request_streaming)
inline bool Method::_internal_request_streaming() const {
return request_streaming_;
}
inline void Method::set_request_streaming(bool value) {
inline bool Method::request_streaming() const {
// @@protoc_insertion_point(field_get:google.protobuf.Method.request_streaming)
return _internal_request_streaming();
}
inline void Method::_internal_set_request_streaming(bool value) {
request_streaming_ = value;
}
inline void Method::set_request_streaming(bool value) {
_internal_set_request_streaming(value);
// @@protoc_insertion_point(field_set:google.protobuf.Method.request_streaming)
}
@ -1138,20 +1219,29 @@ inline void Method::set_allocated_response_type_url(std::string* response_type_u
inline void Method::clear_response_streaming() {
response_streaming_ = false;
}
inline bool Method::response_streaming() const {
// @@protoc_insertion_point(field_get:google.protobuf.Method.response_streaming)
inline bool Method::_internal_response_streaming() const {
return response_streaming_;
}
inline void Method::set_response_streaming(bool value) {
inline bool Method::response_streaming() const {
// @@protoc_insertion_point(field_get:google.protobuf.Method.response_streaming)
return _internal_response_streaming();
}
inline void Method::_internal_set_response_streaming(bool value) {
response_streaming_ = value;
}
inline void Method::set_response_streaming(bool value) {
_internal_set_response_streaming(value);
// @@protoc_insertion_point(field_set:google.protobuf.Method.response_streaming)
}
// repeated .google.protobuf.Option options = 6;
inline int Method::options_size() const {
inline int Method::_internal_options_size() const {
return options_.size();
}
inline int Method::options_size() const {
return _internal_options_size();
}
inline PROTOBUF_NAMESPACE_ID::Option* Method::mutable_options(int index) {
// @@protoc_insertion_point(field_mutable:google.protobuf.Method.options)
return options_.Mutable(index);
@ -1161,13 +1251,19 @@ Method::mutable_options() {
// @@protoc_insertion_point(field_mutable_list:google.protobuf.Method.options)
return &options_;
}
inline const PROTOBUF_NAMESPACE_ID::Option& Method::_internal_options(int index) const {
return options_.Get(index);
}
inline const PROTOBUF_NAMESPACE_ID::Option& Method::options(int index) const {
// @@protoc_insertion_point(field_get:google.protobuf.Method.options)
return options_.Get(index);
return _internal_options(index);
}
inline PROTOBUF_NAMESPACE_ID::Option* Method::_internal_add_options() {
return options_.Add();
}
inline PROTOBUF_NAMESPACE_ID::Option* Method::add_options() {
// @@protoc_insertion_point(field_add:google.protobuf.Method.options)
return options_.Add();
return _internal_add_options();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::Option >&
Method::options() const {
@ -1179,13 +1275,19 @@ Method::options() const {
inline void Method::clear_syntax() {
syntax_ = 0;
}
inline PROTOBUF_NAMESPACE_ID::Syntax Method::syntax() const {
// @@protoc_insertion_point(field_get:google.protobuf.Method.syntax)
inline PROTOBUF_NAMESPACE_ID::Syntax Method::_internal_syntax() const {
return static_cast< PROTOBUF_NAMESPACE_ID::Syntax >(syntax_);
}
inline void Method::set_syntax(PROTOBUF_NAMESPACE_ID::Syntax value) {
inline PROTOBUF_NAMESPACE_ID::Syntax Method::syntax() const {
// @@protoc_insertion_point(field_get:google.protobuf.Method.syntax)
return _internal_syntax();
}
inline void Method::_internal_set_syntax(PROTOBUF_NAMESPACE_ID::Syntax value) {
syntax_ = value;
}
inline void Method::set_syntax(PROTOBUF_NAMESPACE_ID::Syntax value) {
_internal_set_syntax(value);
// @@protoc_insertion_point(field_set:google.protobuf.Method.syntax)
}

2
src/google/protobuf/arena.h
View File

@ -690,7 +690,7 @@ class PROTOBUF_EXPORT alignas(8) Arena final {
!has_get_arena<T>::value,
int>::type = 0>
PROTOBUF_ALWAYS_INLINE static Arena* GetArenaInternal(const T* value) {
(void) value;
(void)value;
return nullptr;
}

34
src/google/protobuf/compiler/command_line_interface.cc
View File

@ -413,7 +413,9 @@ class CommandLineInterface::MemoryOutputStream
// implements ZeroCopyOutputStream ---------------------------------
virtual bool Next(void** data, int* size) { return inner_->Next(data, size); }
virtual void BackUp(int count) { inner_->BackUp(count); }
virtual int64 ByteCount() const { return inner_->ByteCount(); }
virtual int64 ByteCount() const {
return inner_->ByteCount();
}
private:
// Checks to see if "filename_.meta" exists in directory_; if so, fixes the
@ -1062,15 +1064,19 @@ bool CommandLineInterface::ParseInputFiles(
DescriptorPool* descriptor_pool,
std::vector<const FileDescriptor*>* parsed_files) {
// Track unused imports in all source files
for (const auto& input_file : input_files_) {
descriptor_pool->AddUnusedImportTrackFile(input_file);
}
bool result = true;
// Parse each file.
for (const auto& input_file : input_files_) {
// Import the file.
descriptor_pool->AddUnusedImportTrackFile(input_file);
const FileDescriptor* parsed_file =
descriptor_pool->FindFileByName(input_file);
descriptor_pool->ClearUnusedImportTrackFiles();
if (parsed_file == NULL) {
return false;
result = false;
break;
}
parsed_files->push_back(parsed_file);
@ -1080,7 +1086,8 @@ bool CommandLineInterface::ParseInputFiles(
<< ": This file contains services, but "
"--disallow_services was used."
<< std::endl;
return false;
result = false;
break;
}
// Enforce --direct_dependencies
@ -1098,11 +1105,13 @@ bool CommandLineInterface::ParseInputFiles(
}
}
if (indirect_imports) {
return false;
result = false;
break;
}
}
}
return true;
descriptor_pool->ClearUnusedImportTrackFiles();
return result;
}
void CommandLineInterface::Clear() {
@ -1431,13 +1440,12 @@ CommandLineInterface::InterpretArgument(const std::string& name,
// On Windows, the shell (typically cmd.exe) does not expand wildcards in
// file names (e.g. foo\*.proto), so we do it ourselves.
switch (google::protobuf::io::win32::ExpandWildcards(
value,
[this](const string& path) {
this->input_files_.push_back(path);
})) {
value,
[this](const string& path) { this->input_files_.push_back(path); })) {
case google::protobuf::io::win32::ExpandWildcardsResult::kSuccess:
break;
case google::protobuf::io::win32::ExpandWildcardsResult::kErrorNoMatchingFile:
case google::protobuf::io::win32::ExpandWildcardsResult::
kErrorNoMatchingFile:
// Path does not exist, is not a file, or it's longer than MAX_PATH and
// long path handling is disabled.
std::cerr << "Invalid file name pattern or missing input file \""
@ -1448,7 +1456,7 @@ CommandLineInterface::InterpretArgument(const std::string& name,
<< "\" to or from Windows style" << std::endl;
return PARSE_ARGUMENT_FAIL;
}
#else // not _WIN32
#else // not _WIN32
// On other platforms than Windows (e.g. Linux, Mac OS) the shell (typically
// Bash) expands wildcards.
input_files_.push_back(value);

75
src/google/protobuf/compiler/command_line_interface_unittest.cc
View File

@ -56,9 +56,9 @@
#include <google/protobuf/io/zero_copy_stream.h>
#include <google/protobuf/descriptor.pb.h>
#include <google/protobuf/descriptor.h>
#include <google/protobuf/stubs/substitute.h>
#include <google/protobuf/testing/googletest.h>
#include <gtest/gtest.h>
#include <google/protobuf/stubs/substitute.h>
#include <google/protobuf/io/io_win32.h>
#include <google/protobuf/stubs/strutil.h>
@ -142,6 +142,10 @@ class CommandLineInterfaceTest : public testing::Test {
// substring.
void ExpectErrorSubstring(const std::string& expected_substring);
// Checks that Run() returned zero and the stderr contains the given
// substring.
void ExpectWarningSubstring(const std::string& expected_substring);
// Checks that the captured stdout is the same as the expected_text.
void ExpectCapturedStdout(const std::string& expected_text);
@ -406,6 +410,12 @@ void CommandLineInterfaceTest::ExpectErrorSubstring(
EXPECT_PRED_FORMAT2(testing::IsSubstring, expected_substring, error_text_);
}
void CommandLineInterfaceTest::ExpectWarningSubstring(
const std::string& expected_substring) {
EXPECT_EQ(0, return_code_);
EXPECT_PRED_FORMAT2(testing::IsSubstring, expected_substring, error_text_);
}
#if defined(_WIN32) && !defined(__CYGWIN__)
bool CommandLineInterfaceTest::HasAlternateErrorSubstring(
const std::string& expected_substring) {
@ -835,6 +845,69 @@ TEST_F(CommandLineInterfaceTest,
ExpectErrorSubstring("bar.proto: \"Baz\" is not defined.");
}
TEST_F(CommandLineInterfaceTest,
OnlyReportsUnusedImportsForFilesBeingGenerated) {
CreateTempFile("unused.proto",
"syntax = \"proto2\";\n"
"message Unused {}\n");
CreateTempFile("bar.proto",
"syntax = \"proto2\";\n"
"import \"unused.proto\";\n"
"message Bar {}\n");
CreateTempFile("foo.proto",
"syntax = \"proto2\";\n"
"import \"bar.proto\";\n"
"message Foo {\n"
" optional Bar bar = 1;\n"
"}\n");
Run("protocol_compiler --test_out=$tmpdir "
"--proto_path=$tmpdir foo.proto");
ExpectNoErrors();
}
TEST_F(CommandLineInterfaceTest, ReportsTransitiveMisingImports_LeafFirst) {
CreateTempFile("unused.proto",
"syntax = \"proto2\";\n"
"message Unused {}\n");
CreateTempFile("bar.proto",
"syntax = \"proto2\";\n"
"import \"unused.proto\";\n"
"message Bar {}\n");
CreateTempFile("foo.proto",
"syntax = \"proto2\";\n"
"import \"bar.proto\";\n"
"message Foo {\n"
" optional Bar bar = 1;\n"
"}\n");
Run("protocol_compiler --test_out=$tmpdir "
"--proto_path=$tmpdir bar.proto foo.proto");
ExpectWarningSubstring(
"bar.proto:2:1: warning: Import unused.proto but not used.");
}
TEST_F(CommandLineInterfaceTest, ReportsTransitiveMisingImports_LeafLast) {
CreateTempFile("unused.proto",
"syntax = \"proto2\";\n"
"message Unused {}\n");
CreateTempFile("bar.proto",
"syntax = \"proto2\";\n"
"import \"unused.proto\";\n"
"message Bar {}\n");
CreateTempFile("foo.proto",
"syntax = \"proto2\";\n"
"import \"bar.proto\";\n"
"message Foo {\n"
" optional Bar bar = 1;\n"
"}\n");
Run("protocol_compiler --test_out=$tmpdir "
"--proto_path=$tmpdir foo.proto bar.proto");
ExpectWarningSubstring(
"bar.proto:2:1: warning: Import unused.proto but not used.");
}
TEST_F(CommandLineInterfaceTest, CreateDirectory) {
// Test that when we output to a sub-directory, it is created.

21
src/google/protobuf/compiler/cpp/cpp_bootstrap_unittest.cc
View File

@ -44,6 +44,8 @@
#include <map>
#include <google/protobuf/testing/file.h>
#include <google/protobuf/testing/file.h>
#include <google/protobuf/compiler/cpp/cpp_helpers.h>
#include <google/protobuf/compiler/cpp/cpp_generator.h>
#include <google/protobuf/compiler/importer.h>
@ -51,15 +53,12 @@
#include <google/protobuf/io/zero_copy_stream_impl.h>
#include <google/protobuf/descriptor.h>
#include <google/protobuf/stubs/strutil.h>
#include <google/protobuf/testing/googletest.h>
#include <gtest/gtest.h>
#include <google/protobuf/stubs/substitute.h>
#include <google/protobuf/stubs/map_util.h>
#include <google/protobuf/stubs/stl_util.h>
#include <google/protobuf/testing/file.h>
#include <google/protobuf/testing/file.h>
#include <google/protobuf/testing/googletest.h>
#include <gtest/gtest.h>
namespace google {
namespace protobuf {
namespace compiler {
@ -178,16 +177,16 @@ TEST(BootstrapTest, GeneratedFilesMatch) {
}
}
//test Generate in cpp_generator.cc
TEST(BootstrapTest, OptionNotExist)
{
// test Generate in cpp_generator.cc
TEST(BootstrapTest, OptionNotExist) {
cpp::CppGenerator generator;
DescriptorPool pool;
GeneratorContext *generator_context = nullptr;
GeneratorContext* generator_context = nullptr;
std::string parameter = "aaa";
string error;
ASSERT_FALSE(generator.Generate(pool.FindFileByName("google/protobuf/descriptor.proto"),
parameter, generator_context, &error));
ASSERT_FALSE(generator.Generate(
pool.FindFileByName("google/protobuf/descriptor.proto"), parameter,
generator_context, &error));
EXPECT_EQ(error, "Unknown generator option: " + parameter);
}

118
src/google/protobuf/compiler/cpp/cpp_enum_field.cc
View File

@ -77,7 +77,11 @@ void EnumFieldGenerator::GenerateAccessorDeclarations(
Formatter format(printer, variables_);
format(
"$deprecated_attr$$type$ ${1$$name$$}$() const;\n"
"$deprecated_attr$void ${1$set_$name$$}$($type$ value);\n",
"$deprecated_attr$void ${1$set_$name$$}$($type$ value);\n"
"private:\n"
"$type$ ${1$_internal_$name$$}$() const;\n"
"void ${1$_internal_set_$name$$}$($type$ value);\n"
"public:\n",
descriptor_);
}
@ -85,19 +89,25 @@ void EnumFieldGenerator::GenerateInlineAccessorDefinitions(
io::Printer* printer) const {
Formatter format(printer, variables_);
format(
"inline $type$ $classname$::_internal_$name$() const {\n"
" return static_cast< $type$ >($name$_);\n"
"}\n"
"inline $type$ $classname$::$name$() const {\n"
"$annotate_accessor$"
" // @@protoc_insertion_point(field_get:$full_name$)\n"
" return static_cast< $type$ >($name$_);\n"
" return _internal_$name$();\n"
"}\n"
"inline void $classname$::set_$name$($type$ value) {\n"
"$annotate_accessor$");
"inline void $classname$::_internal_set_$name$($type$ value) {\n");
if (!HasPreservingUnknownEnumSemantics(descriptor_)) {
format(" assert($type$_IsValid(value));\n");
}
format(
" $set_hasbit$\n"
" $name$_ = value;\n"
"}\n"
"inline void $classname$::set_$name$($type$ value) {\n"
"$annotate_accessor$"
" _internal_set_$name$(value);\n"
" // @@protoc_insertion_point(field_set:$full_name$)\n"
"}\n");
}
@ -109,7 +119,7 @@ void EnumFieldGenerator::GenerateClearingCode(io::Printer* printer) const {
void EnumFieldGenerator::GenerateMergingCode(io::Printer* printer) const {
Formatter format(printer, variables_);
format("set_$name$(from.$name$());\n");
format("_internal_set_$name$(from._internal_$name$());\n");
}
void EnumFieldGenerator::GenerateSwappingCode(io::Printer* printer) const {
@ -128,51 +138,22 @@ void EnumFieldGenerator::GenerateCopyConstructorCode(
format("$name$_ = from.$name$_;\n");
}
void EnumFieldGenerator::GenerateMergeFromCodedStream(
io::Printer* printer) const {
Formatter format(printer, variables_);
format(
"int value = 0;\n"
"DO_((::$proto_ns$::internal::WireFormatLite::ReadPrimitive<\n"
" int, ::$proto_ns$::internal::WireFormatLite::TYPE_ENUM>(\n"
" input, &value)));\n");
if (HasPreservingUnknownEnumSemantics(descriptor_)) {
format("set_$name$(static_cast< $type$ >(value));\n");
} else {
format(
"if ($type$_IsValid(value)) {\n"
" set_$name$(static_cast< $type$ >(value));\n");
if (UseUnknownFieldSet(descriptor_->file(), options_)) {
format(
"} else {\n"
" mutable_unknown_fields()->AddVarint(\n"
" $number$, static_cast<$uint64$>(value));\n");
} else {
format(
"} else {\n"
" unknown_fields_stream.WriteVarint32($1$u);\n"
" unknown_fields_stream.WriteVarint32(\n"
" static_cast<$uint32$>(value));\n",
internal::WireFormat::MakeTag(descriptor_));
}
format("}\n");
}
}
void EnumFieldGenerator::GenerateSerializeWithCachedSizesToArray(
io::Printer* printer) const {
Formatter format(printer, variables_);
format(
"stream->EnsureSpace(&target);\n"
"target = ::$proto_ns$::internal::WireFormatLite::WriteEnumToArray(\n"
" $number$, this->$name$(), target);\n");
" $number$, this->_internal_$name$(), target);\n");
}
void EnumFieldGenerator::GenerateByteSize(io::Printer* printer) const {
Formatter format(printer, variables_);
format(
"total_size += $tag_size$ +\n"
" ::$proto_ns$::internal::WireFormatLite::EnumSize(this->$name$());\n");
" "
"::$proto_ns$::internal::WireFormatLite::EnumSize(this->_internal_$name$("
"));\n");
}
// ===================================================================
@ -189,26 +170,32 @@ void EnumOneofFieldGenerator::GenerateInlineAccessorDefinitions(
io::Printer* printer) const {
Formatter format(printer, variables_);
format(
"inline $type$ $classname$::$name$() const {\n"
"$annotate_accessor$"
" // @@protoc_insertion_point(field_get:$full_name$)\n"
" if (has_$name$()) {\n"
"inline $type$ $classname$::_internal_$name$() const {\n"
" if (_internal_has_$name$()) {\n"
" return static_cast< $type$ >($field_member$);\n"
" }\n"
" return static_cast< $type$ >($default$);\n"
"}\n"
"inline void $classname$::set_$name$($type$ value) {\n"
"$annotate_accessor$");
"inline $type$ $classname$::$name$() const {\n"
"$annotate_accessor$"
" // @@protoc_insertion_point(field_get:$full_name$)\n"
" return _internal_$name$();\n"
"}\n"
"inline void $classname$::_internal_set_$name$($type$ value) {\n");
if (!HasPreservingUnknownEnumSemantics(descriptor_)) {
format(" assert($type$_IsValid(value));\n");
}
format(
" if (!has_$name$()) {\n"
" if (!_internal_has_$name$()) {\n"
" clear_$oneof_name$();\n"
" set_has_$name$();\n"
" }\n"
" $field_member$ = value;\n"
"}\n"
"inline void $classname$::set_$name$($type$ value) {\n"
"$annotate_accessor$"
" // @@protoc_insertion_point(field_set:$full_name$)\n"
" _internal_set_$name$(value);\n"
"}\n");
}
@ -251,6 +238,12 @@ void RepeatedEnumFieldGenerator::GenerateAccessorDeclarations(
io::Printer* printer) const {
Formatter format(printer, variables_);
format(
"private:\n"
"$type$ ${1$_internal_$name$$}$(int index) const;\n"
"void ${1$_internal_add_$name$$}$($type$ value);\n"
"::$proto_ns$::RepeatedField<int>* "
"${1$_internal_mutable_$name$$}$();\n"
"public:\n"
"$deprecated_attr$$type$ ${1$$name$$}$(int index) const;\n"
"$deprecated_attr$void ${1$set_$name$$}$(int index, $type$ value);\n"
"$deprecated_attr$void ${1$add_$name$$}$($type$ value);\n"
@ -265,10 +258,13 @@ void RepeatedEnumFieldGenerator::GenerateInlineAccessorDefinitions(
io::Printer* printer) const {
Formatter format(printer, variables_);
format(
"inline $type$ $classname$::_internal_$name$(int index) const {\n"
" return static_cast< $type$ >($name$_.Get(index));\n"
"}\n"
"inline $type$ $classname$::$name$(int index) const {\n"
"$annotate_accessor$"
" // @@protoc_insertion_point(field_get:$full_name$)\n"
" return static_cast< $type$ >($name$_.Get(index));\n"
" return _internal_$name$(index);\n"
"}\n"
"inline void $classname$::set_$name$(int index, $type$ value) {\n"
"$annotate_accessor$");
@ -279,14 +275,17 @@ void RepeatedEnumFieldGenerator::GenerateInlineAccessorDefinitions(
" $name$_.Set(index, value);\n"
" // @@protoc_insertion_point(field_set:$full_name$)\n"
"}\n"
"inline void $classname$::add_$name$($type$ value) {\n"
"$annotate_accessor$");
"inline void $classname$::_internal_add_$name$($type$ value) {\n");
if (!HasPreservingUnknownEnumSemantics(descriptor_)) {
format(" assert($type$_IsValid(value));\n");
}
format(
" $name$_.Add(value);\n"
"}\n"
"inline void $classname$::add_$name$($type$ value) {\n"
"$annotate_accessor$"
" // @@protoc_insertion_point(field_add:$full_name$)\n"
" _internal_add_$name$(value);\n"
"}\n"
"inline const ::$proto_ns$::RepeatedField<int>&\n"
"$classname$::$name$() const {\n"
@ -295,10 +294,14 @@ void RepeatedEnumFieldGenerator::GenerateInlineAccessorDefinitions(
" return $name$_;\n"
"}\n"
"inline ::$proto_ns$::RepeatedField<int>*\n"
"$classname$::_internal_mutable_$name$() {\n"
" return &$name$_;\n"
"}\n"
"inline ::$proto_ns$::RepeatedField<int>*\n"
"$classname$::mutable_$name$() {\n"
"$annotate_accessor$"
" // @@protoc_insertion_point(field_mutable_list:$full_name$)\n"
" return &$name$_;\n"
" return _internal_mutable_$name$();\n"
"}\n");
}
@ -369,7 +372,7 @@ void RepeatedEnumFieldGenerator::GenerateMergeFromCodedStreamWithPacking(
" $number$,\n"
" nullptr,\n"
" nullptr,\n"
" this->mutable_$name$())));\n");
" this->_internal_mutable_$name$())));\n");
} else if (UseUnknownFieldSet(descriptor_->file(), options_)) {
format(
"DO_((::$proto_ns$::internal::WireFormat::"
@ -378,7 +381,7 @@ void RepeatedEnumFieldGenerator::GenerateMergeFromCodedStreamWithPacking(
" $number$,\n"
" $type$_IsValid,\n"
" mutable_unknown_fields(),\n"
" this->mutable_$name$())));\n");
" this->_internal_mutable_$name$())));\n");
} else {
format(
"DO_((::$proto_ns$::internal::"
@ -387,7 +390,7 @@ void RepeatedEnumFieldGenerator::GenerateMergeFromCodedStreamWithPacking(
" $number$,\n"
" $type$_IsValid,\n"
" &unknown_fields_stream,\n"
" this->mutable_$name$())));\n");
" this->_internal_mutable_$name$())));\n");
}
} else {
format(
@ -405,7 +408,7 @@ void RepeatedEnumFieldGenerator::GenerateMergeFromCodedStreamWithPacking(
} else {
format(
" if ($type$_IsValid(value)) {\n"
" add_$name$(static_cast< $type$ >(value));\n"
" _internal_add_$name$(static_cast< $type$ >(value));\n"
" } else {\n");
if (UseUnknownFieldSet(descriptor_->file(), options_)) {
format(
@ -441,10 +444,10 @@ void RepeatedEnumFieldGenerator::GenerateSerializeWithCachedSizesToArray(
"}\n");
} else {
format(
"for (const auto& x : this->$name$()) {\n"
"for (int i = 0, n = this->_internal_$name$_size(); i < n; i++) {\n"
" stream->EnsureSpace(&target);\n"
" target = ::$proto_ns$::internal::WireFormatLite::WriteEnumToArray(\n"
" $number$, x, target);\n"
" $number$, this->_internal_$name$(i), target);\n"
"}\n");
}
}
@ -454,12 +457,13 @@ void RepeatedEnumFieldGenerator::GenerateByteSize(io::Printer* printer) const {
format(
"{\n"
" size_t data_size = 0;\n"
" unsigned int count = static_cast<unsigned int>(this->$name$_size());");
" unsigned int count = static_cast<unsigned "
"int>(this->_internal_$name$_size());");
format.Indent();
format(
"for (unsigned int i = 0; i < count; i++) {\n"
" data_size += ::$proto_ns$::internal::WireFormatLite::EnumSize(\n"
" this->$name$(static_cast<int>(i)));\n"
" this->_internal_$name$(static_cast<int>(i)));\n"
"}\n");
if (descriptor_->is_packed()) {

1
src/google/protobuf/compiler/cpp/cpp_enum_field.h
View File

@ -58,7 +58,6 @@ class EnumFieldGenerator : public FieldGenerator {
void GenerateSwappingCode(io::Printer* printer) const;
void GenerateConstructorCode(io::Printer* printer) const;
void GenerateCopyConstructorCode(io::Printer* printer) const;
void GenerateMergeFromCodedStream(io::Printer* printer) const;
void GenerateSerializeWithCachedSizesToArray(io::Printer* printer) const;
void GenerateByteSize(io::Printer* printer) const;

11
src/google/protobuf/compiler/cpp/cpp_field.cc
View File

@ -113,17 +113,6 @@ void SetCommonOneofFieldVariables(
FieldGenerator::~FieldGenerator() {}
void FieldGenerator::GenerateMergeFromCodedStreamWithPacking(
io::Printer* printer) const {
// Reaching here indicates a bug. Cases are:
// - This FieldGenerator should support packing, but this method should be
// overridden.
// - This FieldGenerator doesn't support packing, and this method should
// never have been called.
GOOGLE_LOG(FATAL) << "GenerateMergeFromCodedStreamWithPacking() "
<< "called on field generator that does not support packing.";
}
FieldGeneratorMap::FieldGeneratorMap(const Descriptor* descriptor,
const Options& options,
MessageSCCAnalyzer* scc_analyzer)

13
src/google/protobuf/compiler/cpp/cpp_field.h
View File

@ -168,19 +168,6 @@ class FieldGenerator {
virtual void GenerateDefaultInstanceAllocator(
io::Printer* /*printer*/) const {}
// Generate lines to decode this field, which will be placed inside the
// message's MergeFromCodedStream() method.
virtual void GenerateMergeFromCodedStream(io::Printer* printer) const = 0;
// Returns true if this field's "MergeFromCodedStream" code needs the arena
// to be defined as a variable.
virtual bool MergeFromCodedStreamNeedsArena() const { return false; }
// Generate lines to decode this field from a packed value, which will be
// placed inside the message's MergeFromCodedStream() method.
virtual void GenerateMergeFromCodedStreamWithPacking(
io::Printer* printer) const;
// Generate lines to serialize this field directly to the array "target",
// which are placed within the message's SerializeWithCachedSizesToArray()
// method. This must also advance "target" past the written bytes.

13
src/google/protobuf/compiler/cpp/cpp_file.cc
View File

@ -414,7 +414,7 @@ void FileGenerator::GenerateSourceIncludes(io::Printer* printer) {
if (IsProto2MessageSetFile(file_, options_)) {
format(
// Implementation of proto1 MessageSet API methods.
"#include \"net/proto2/bridge/internal/message_set_util.h\"\n");
"#include \"net/proto2/internal/message_set_util.h\"\n");
}
if (options_.proto_h) {
@ -591,10 +591,6 @@ void FileGenerator::GenerateSourceForMessage(int idx, io::Printer* printer) {
// Define default instances
GenerateSourceDefaultInstance(idx, printer);
if (options_.lite_implicit_weak_fields) {
format("void $1$_ReferenceStrong() {}\n",
message_generators_[idx]->classname_);
}
// Generate classes.
format("\n");
@ -665,10 +661,6 @@ void FileGenerator::GenerateSource(io::Printer* printer) {
// Define default instances
for (int i = 0; i < message_generators_.size(); i++) {
GenerateSourceDefaultInstance(i, printer);
if (options_.lite_implicit_weak_fields) {
format("void $1$_ReferenceStrong() {}\n",
message_generators_[i]->classname_);
}
}
}
@ -1159,9 +1151,6 @@ class FileGenerator::ForwardDeclarations {
"$dllexport_decl $extern $3$ $4$;\n",
class_desc, classname, DefaultInstanceType(class_desc, options),
DefaultInstanceName(class_desc, options));
if (options.lite_implicit_weak_fields) {
format("void $1$_ReferenceStrong();\n", classname);
}
}
}

30
src/google/protobuf/compiler/cpp/cpp_helpers.cc
View File

@ -202,7 +202,7 @@ void SetIntVar(const Options& options, const std::string& type,
}
bool HasInternalAccessors(const FieldOptions::CType ctype) {
return ctype == FieldOptions::STRING;
return ctype == FieldOptions::STRING || ctype == FieldOptions::CORD;
}
} // namespace
@ -399,11 +399,6 @@ std::string FileDllExport(const FileDescriptor* file, const Options& options) {
return UniqueName("PROTOBUF_INTERNAL_EXPORT", file, options);
}
std::string ReferenceFunctionName(const Descriptor* descriptor,
const Options& options) {
return QualifiedClassName(descriptor, options) + "_ReferenceStrong";
}
std::string SuperClassName(const Descriptor* descriptor,
const Options& options) {
return "::" + ProtobufNamespace(options) +
@ -1505,9 +1500,11 @@ class ParseLoopGenerator {
StrCat(", ", QualifiedClassName(field->enum_type(), options_),
"_IsValid, &_internal_metadata_, ", field->number());
}
format_("ptr = $pi_ns$::Packed$1$Parser(mutable_$2$(), ptr, ctx$3$);\n",
DeclaredTypeMethodName(field->type()), FieldName(field),
enum_validator);
format_(
"ptr = $pi_ns$::Packed$1$Parser(_internal_mutable_$2$(), ptr, "
"ctx$3$);\n",
DeclaredTypeMethodName(field->type()), FieldName(field),
enum_validator);
} else {
auto field_type = field->type();
switch (field_type) {
@ -1537,8 +1534,8 @@ class ParseLoopGenerator {
} else if (IsLazy(field, options_)) {
if (field->containing_oneof() != nullptr) {
format_(
"if (!has_$1$()) {\n"
" clear_$1$();\n"
"if (!_internal_has_$1$()) {\n"
" clear_$2$();\n"
" $2$_.$1$_ = ::$proto_ns$::Arena::CreateMessage<\n"
" $pi_ns$::LazyField>("
"GetArenaNoVirtual());\n"
@ -1575,7 +1572,7 @@ class ParseLoopGenerator {
" _$classname$_default_instance_.$2$_), ptr);\n",
field->number(), FieldName(field));
} else {
format_("ptr = ctx->ParseMessage($1$_$2$(), ptr);\n",
format_("ptr = ctx->ParseMessage(_internal_$1$_$2$(), ptr);\n",
field->is_repeated() ? "add" : "mutable", FieldName(field));
}
break;
@ -1619,7 +1616,8 @@ class ParseLoopGenerator {
QualifiedClassName(field->enum_type(), options_));
format_.Indent();
}
format_("$1$_$2$(static_cast<$3$>(val));\n", prefix, FieldName(field),
format_("_internal_$1$_$2$(static_cast<$3$>(val));\n", prefix,
FieldName(field),
QualifiedClassName(field->enum_type(), options_));
if (!HasPreservingUnknownEnumSemantics(field)) {
format_.Outdent();
@ -1639,7 +1637,7 @@ class ParseLoopGenerator {
if (field->is_repeated() || field->containing_oneof()) {
string prefix = field->is_repeated() ? "add" : "set";
format_(
"$1$_$2$($pi_ns$::ReadVarint$3$(&ptr));\n"
"_internal_$1$_$2$($pi_ns$::ReadVarint$3$(&ptr));\n"
"CHK_(ptr);\n",
prefix, FieldName(field), zigzag);
} else {
@ -1661,7 +1659,7 @@ class ParseLoopGenerator {
if (field->is_repeated() || field->containing_oneof()) {
string prefix = field->is_repeated() ? "add" : "set";
format_(
"$1$_$2$($pi_ns$::UnalignedLoad<$3$>(ptr));\n"
"_internal_$1$_$2$($pi_ns$::UnalignedLoad<$3$>(ptr));\n"
"ptr += sizeof($3$);\n",
prefix, FieldName(field), type);
} else {
@ -1682,7 +1680,7 @@ class ParseLoopGenerator {
}
case WireFormatLite::WIRETYPE_START_GROUP: {
format_(
"ptr = ctx->ParseGroup($1$_$2$(), ptr, $3$);\n"
"ptr = ctx->ParseGroup(_internal_$1$_$2$(), ptr, $3$);\n"
"CHK_(ptr);\n",
field->is_repeated() ? "add" : "mutable", FieldName(field), tag);
break;

7
src/google/protobuf/compiler/cpp/cpp_helpers.h
View File

@ -49,6 +49,7 @@
#include <google/protobuf/port.h>
#include <google/protobuf/stubs/strutil.h>
// Must be included last.
#include <google/protobuf/port_def.inc>
namespace google {
@ -153,12 +154,6 @@ std::string DescriptorTableName(const FileDescriptor* file,
// dllexport needed for the target file, if any.
std::string FileDllExport(const FileDescriptor* file, const Options& options);
// Returns the name of a no-op function that we can call to introduce a linker
// dependency on the given message type. This is used to implement implicit weak
// fields.
std::string ReferenceFunctionName(const Descriptor* descriptor,
const Options& options);
// Name of the base class: google::protobuf::Message or google::protobuf::MessageLite.
std::string SuperClassName(const Descriptor* descriptor,
const Options& options);

108
src/google/protobuf/compiler/cpp/cpp_map_field.cc
View File

@ -112,6 +112,12 @@ void MapFieldGenerator::GenerateAccessorDeclarations(
io::Printer* printer) const {
Formatter format(printer, variables_);
format(
"private:\n"
"const ::$proto_ns$::Map< $key_cpp$, $val_cpp$ >&\n"
" ${1$_internal_$name$$}$() const;\n"
"::$proto_ns$::Map< $key_cpp$, $val_cpp$ >*\n"
" ${1$_internal_mutable_$name$$}$();\n"
"public:\n"
"$deprecated_attr$const ::$proto_ns$::Map< $key_cpp$, $val_cpp$ >&\n"
" ${1$$name$$}$() const;\n"
"$deprecated_attr$::$proto_ns$::Map< $key_cpp$, $val_cpp$ >*\n"
@ -123,17 +129,25 @@ void MapFieldGenerator::GenerateInlineAccessorDefinitions(
io::Printer* printer) const {
Formatter format(printer, variables_);
format(
"inline const ::$proto_ns$::Map< $key_cpp$, $val_cpp$ >&\n"
"$classname$::_internal_$name$() const {\n"
" return $name$_.GetMap();\n"
"}\n"
"inline const ::$proto_ns$::Map< $key_cpp$, $val_cpp$ >&\n"
"$classname$::$name$() const {\n"
"$annotate_accessor$"
" // @@protoc_insertion_point(field_map:$full_name$)\n"
" return $name$_.GetMap();\n"
" return _internal_$name$();\n"
"}\n"
"inline ::$proto_ns$::Map< $key_cpp$, $val_cpp$ >*\n"
"$classname$::_internal_mutable_$name$() {\n"
" return $name$_.MutableMap();\n"
"}\n"
"inline ::$proto_ns$::Map< $key_cpp$, $val_cpp$ >*\n"
"$classname$::mutable_$name$() {\n"
"$annotate_accessor$"
" // @@protoc_insertion_point(field_mutable_map:$full_name$)\n"
" return $name$_.MutableMap();\n"
" return _internal_mutable_$name$();\n"
"}\n");
}
@ -158,75 +172,6 @@ void MapFieldGenerator::GenerateCopyConstructorCode(
GenerateMergingCode(printer);
}
void MapFieldGenerator::GenerateMergeFromCodedStream(
io::Printer* printer) const {
Formatter format(printer, variables_);
const FieldDescriptor* key_field =
descriptor_->message_type()->FindFieldByName("key");
const FieldDescriptor* value_field =
descriptor_->message_type()->FindFieldByName("value");
std::string key;
std::string value;
format(
"$map_classname$::Parser< ::$proto_ns$::internal::MapField$lite$<\n"
" $map_classname$,\n"
" $key_cpp$, $val_cpp$,\n"
" ::$proto_ns$::internal::WireFormatLite::$key_wire_type$,\n"
" ::$proto_ns$::internal::WireFormatLite::$val_wire_type$,\n"
" $default_enum_value$ >,\n"
" ::$proto_ns$::Map< $key_cpp$, $val_cpp$ > >"
" parser(&$name$_);\n");
if (IsProto3Field(descriptor_) ||
value_field->type() != FieldDescriptor::TYPE_ENUM) {
format(
"DO_(::$proto_ns$::internal::WireFormatLite::ReadMessageNoVirtual(\n"
" input, &parser));\n");
key = "parser.key()";
value = "parser.value()";
} else {
key = "entry->key()";
value = "entry->value()";
format("auto entry = parser.NewEntry();\n");
format(
"std::string data;\n"
"DO_(::$proto_ns$::internal::WireFormatLite::ReadString(input, "
"&data));\n"
"DO_(entry->ParseFromString(data));\n"
"if ($val_cpp$_IsValid(*entry->mutable_value())) {\n"
" (*mutable_$name$())[entry->key()] =\n"
" static_cast< $val_cpp$ >(*entry->mutable_value());\n"
"} else {\n");
if (HasDescriptorMethods(descriptor_->file(), options_)) {
format(
" mutable_unknown_fields()"
"->AddLengthDelimited($number$, data);\n");
} else {
format(
" unknown_fields_stream.WriteVarint32($tag$u);\n"
" unknown_fields_stream.WriteVarint32(\n"
" static_cast< ::google::protobuf::uint32>(data.size()));\n"
" unknown_fields_stream.WriteString(data);\n");
}
format("}\n");
}
if (key_field->type() == FieldDescriptor::TYPE_STRING) {
GenerateUtf8CheckCodeForString(
key_field, options_, true,
StrCat(key, ".data(), static_cast<int>(", key, ".length()),\n")
.data(),
format);
}
if (value_field->type() == FieldDescriptor::TYPE_STRING) {
GenerateUtf8CheckCodeForString(
value_field, options_, true,
StrCat(value, ".data(), static_cast<int>(", value,
".length()),\n")
.data(),
format);
}
}
static void GenerateSerializationLoop(const Formatter& format, bool string_key,
bool string_value,
bool is_deterministic) {
@ -238,8 +183,8 @@ static void GenerateSerializationLoop(const Formatter& format, bool string_key,
} else {
format(
"for (::$proto_ns$::Map< $key_cpp$, $val_cpp$ >::const_iterator\n"
" it = this->$name$().begin();\n"
" it != this->$name$().end(); ++it) {\n");
" it = this->_internal_$name$().begin();\n"
" it != this->_internal_$name$().end(); ++it) {\n");
ptr = "it";
}
format.Indent();
@ -262,7 +207,7 @@ static void GenerateSerializationLoop(const Formatter& format, bool string_key,
void MapFieldGenerator::GenerateSerializeWithCachedSizesToArray(
io::Printer* printer) const {
Formatter format(printer, variables_);
format("if (!this->$name$().empty()) {\n");
format("if (!this->_internal_$name$().empty()) {\n");
format.Indent();
const FieldDescriptor* key_field =
descriptor_->message_type()->FindFieldByName("key");
@ -313,15 +258,15 @@ void MapFieldGenerator::GenerateSerializeWithCachedSizesToArray(
format(
"\n"
"if (stream->IsSerializationDeterministic() &&\n"
" this->$name$().size() > 1) {\n"
" this->_internal_$name$().size() > 1) {\n"
" ::std::unique_ptr<SortItem[]> items(\n"
" new SortItem[this->$name$().size()]);\n"
" new SortItem[this->_internal_$name$().size()]);\n"
" typedef ::$proto_ns$::Map< $key_cpp$, $val_cpp$ >::size_type "
"size_type;\n"
" size_type n = 0;\n"
" for (::$proto_ns$::Map< $key_cpp$, $val_cpp$ >::const_iterator\n"
" it = this->$name$().begin();\n"
" it != this->$name$().end(); ++it, ++n) {\n"
" it = this->_internal_$name$().begin();\n"
" it != this->_internal_$name$().end(); ++it, ++n) {\n"
" items[static_cast<ptrdiff_t>(n)] = SortItem(&*it);\n"
" }\n"
" ::std::sort(&items[0], &items[static_cast<ptrdiff_t>(n)], Less());\n");
@ -341,10 +286,11 @@ void MapFieldGenerator::GenerateByteSize(io::Printer* printer) const {
Formatter format(printer, variables_);
format(
"total_size += $tag_size$ *\n"
" ::$proto_ns$::internal::FromIntSize(this->$name$_size());\n"
" "
"::$proto_ns$::internal::FromIntSize(this->_internal_$name$_size());\n"
"for (::$proto_ns$::Map< $key_cpp$, $val_cpp$ >::const_iterator\n"
" it = this->$name$().begin();\n"
" it != this->$name$().end(); ++it) {\n"
" it = this->_internal_$name$().begin();\n"
" it != this->_internal_$name$().end(); ++it) {\n"
" total_size += $map_classname$::Funcs::ByteSizeLong(it->first, "
"it->second);\n"
"}\n");

1
src/google/protobuf/compiler/cpp/cpp_map_field.h
View File

@ -55,7 +55,6 @@ class MapFieldGenerator : public FieldGenerator {
void GenerateSwappingCode(io::Printer* printer) const;
void GenerateConstructorCode(io::Printer* printer) const {}
void GenerateCopyConstructorCode(io::Printer* printer) const;
void GenerateMergeFromCodedStream(io::Printer* printer) const;
void GenerateSerializeWithCachedSizesToArray(io::Printer* printer) const;
void GenerateByteSize(io::Printer* printer) const;

374
src/google/protobuf/compiler/cpp/cpp_message.cc
View File

@ -185,7 +185,7 @@ bool EmitFieldNonDefaultCondition(io::Printer* printer,
format.Indent();
return true;
} else if (field->containing_oneof()) {
format("if (has_$name$()) {\n");
format("if (_internal_has_$name$()) {\n");
format.Indent();
return true;
}
@ -734,7 +734,12 @@ void MessageGenerator::GenerateFieldAccessorDeclarations(io::Printer* printer) {
format.AddMap(vars);
if (field->is_repeated()) {
format("$deprecated_attr$int ${1$$name$_size$}$() const;\n", field);
format(
"$deprecated_attr$int ${1$$name$_size$}$() const;\n"
"private:\n"
"int ${1$_internal_$name$_size$}$() const;\n"
"public:\n",
field);
} else if (HasHasMethod(field)) {
format(
"$deprecated_attr$bool ${1$has_$name$$}$() const;\n"
@ -745,7 +750,7 @@ void MessageGenerator::GenerateFieldAccessorDeclarations(io::Printer* printer) {
} else if (HasPrivateHasMethod(field)) {
format(
"private:\n"
"bool ${1$has_$name$$}$() const;\n"
"bool ${1$_internal_has_$name$$}$() const;\n"
"public:\n",
field);
}
@ -804,7 +809,19 @@ void MessageGenerator::GenerateSingularFieldHasBits(
strings::Hex(1u << (has_bit_index % 32), strings::ZERO_PAD_8));
format(
"inline bool $classname$::_internal_has_$name$() const {\n"
" return (_has_bits_[$has_array_index$] & 0x$has_mask$u) != 0;\n"
" bool value = "
"(_has_bits_[$has_array_index$] & 0x$has_mask$u) != 0;\n");
if (field->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE &&
!IsLazy(field, options_)) {
// We maintain the invariant that for a submessage x, has_x() returning
// true implies that x_ is not null. By giving this information to the
// compiler, we allow it to eliminate unnecessary null checks later on.
format(" PROTOBUF_ASSUME(!value || $name$_ != nullptr);\n");
}
format(
" return value;\n"
"}\n"
"inline bool $classname$::has_$name$() const {\n"
"$annotate_accessor$"
@ -815,18 +832,21 @@ void MessageGenerator::GenerateSingularFieldHasBits(
if (field->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE) {
if (IsLazy(field, options_)) {
format(
"inline bool $classname$::has_$name$() const {\n"
"$annotate_accessor$"
"inline bool $classname$::_internal_has_$name$() const {\n"
" return !$name$_.IsCleared();\n"
"}\n");
} else {
format(
"inline bool $classname$::has_$name$() const {\n"
"$annotate_accessor$"
"inline bool $classname$::_internal_has_$name$() const {\n"
" return this != internal_default_instance() "
"&& $name$_ != nullptr;\n"
"}\n");
}
format(
"inline bool $classname$::has_$name$() const {\n"
"$annotate_accessor$"
" return _internal_has_$name$();\n"
"}\n");
}
}
}
@ -858,12 +878,7 @@ void MessageGenerator::GenerateOneofMemberHasBits(const FieldDescriptor* field,
//
// If has_$name$() is private, there is no need to add an internal accessor.
// Only annotate public accessors.
if (HasPrivateHasMethod(field)) {
format(
"inline bool $classname$::has_$name$() const {\n"
" return $oneof_name$_case() == k$field_name$;\n"
"}\n");
} else {
if (HasHasMethod(field)) {
format(
"inline bool $classname$::_internal_has_$name$() const {\n"
" return $oneof_name$_case() == k$field_name$;\n"
@ -872,6 +887,11 @@ void MessageGenerator::GenerateOneofMemberHasBits(const FieldDescriptor* field,
"$annotate_accessor$"
" return _internal_has_$name$();\n"
"}\n");
} else if (HasPrivateHasMethod(field)) {
format(
"inline bool $classname$::_internal_has_$name$() const {\n"
" return $oneof_name$_case() == k$field_name$;\n"
"}\n");
}
// set_has_$name$() for oneof fields is always private; hence should not be
// annotated.
@ -896,7 +916,7 @@ void MessageGenerator::GenerateFieldClear(const FieldDescriptor* field,
if (field->containing_oneof()) {
// Clear this field only if it is the active field in this oneof,
// otherwise ignore
format("if (has_$name$()) {\n");
format("if (_internal_has_$name$()) {\n");
format.Indent();
field_generators_.get(field).GenerateClearingCode(format.printer());
format("clear_has_$oneof_name$();\n");
@ -937,9 +957,12 @@ void MessageGenerator::GenerateFieldAccessorDefinitions(io::Printer* printer) {
// Generate has_$name$() or $name$_size().
if (field->is_repeated()) {
format(
"inline int $classname$::_internal_$name$_size() const {\n"
" return $name$_$1$.size();\n"
"}\n"
"inline int $classname$::$name$_size() const {\n"
"$annotate_accessor$"
" return $name$_$1$.size();\n"
" return _internal_$name$_size();\n"
"}\n",
IsImplicitWeakField(field, options_, scc_analyzer_) &&
field->message_type()
@ -1313,13 +1336,8 @@ void MessageGenerator::GenerateClassDefinition(io::Printer* printer) {
"bool IsInitialized() const$ is_initialized_final$;\n"
"\n"
"size_t ByteSizeLong() const final;\n"
"#if $GOOGLE_PROTOBUF$_ENABLE_EXPERIMENTAL_PARSER\n"
"const char* _InternalParse(const char* ptr, "
"::$proto_ns$::internal::ParseContext* ctx) final;\n"
"#else\n"
"bool MergePartialFromCodedStream(\n"
" ::$proto_ns$::io::CodedInputStream* input) final;\n"
"#endif // $GOOGLE_PROTOBUF$_ENABLE_EXPERIMENTAL_PARSER\n"
"$uint8$* InternalSerializeWithCachedSizesToArray(\n"
" $uint8$* target, ::$proto_ns$::io::EpsCopyOutputStream* stream) "
"const final;\n");
@ -3226,7 +3244,7 @@ void MessageGenerator::GenerateMergeFrom(io::Printer* printer) {
format("if (cached_has_bits & 0x$1$u) {\n", mask);
} else {
format("if (from.has_$1$()) {\n", FieldName(field));
format("if (from._internal_has_$1$()) {\n", FieldName(field));
}
format.Indent();
@ -3384,322 +3402,15 @@ void MessageGenerator::GenerateMergeFromCodedStream(io::Printer* printer) {
if (descriptor_->options().message_set_wire_format()) {
// Special-case MessageSet.
format(
"#if $GOOGLE_PROTOBUF$_ENABLE_EXPERIMENTAL_PARSER\n"
"const char* $classname$::_InternalParse(const char* ptr,\n"
" ::$proto_ns$::internal::ParseContext* ctx) {\n"
" return _extensions_.ParseMessageSet(ptr, \n"
" internal_default_instance(), &_internal_metadata_, ctx);\n"
"}\n"
"#else\n"
"bool $classname$::MergePartialFromCodedStream(\n"
" ::$proto_ns$::io::CodedInputStream* input) {\n"
" return _extensions_.ParseMessageSet(input,\n"
" internal_default_instance(), $mutable_unknown_fields$);\n"
"}\n"
"#endif // $GOOGLE_PROTOBUF$_ENABLE_EXPERIMENTAL_PARSER\n");
"}\n");
return;
}
format("#if $GOOGLE_PROTOBUF$_ENABLE_EXPERIMENTAL_PARSER\n");
GenerateParserLoop(descriptor_, max_has_bit_index_, options_, scc_analyzer_,
printer);
format("#else // $GOOGLE_PROTOBUF$_ENABLE_EXPERIMENTAL_PARSER\n");
std::vector<const FieldDescriptor*> ordered_fields =
SortFieldsByNumber(descriptor_);
format(
"bool $classname$::MergePartialFromCodedStream(\n"
" ::$proto_ns$::io::CodedInputStream* input) {\n");
if (table_driven_) {
format.Indent();
const std::string lite =
UseUnknownFieldSet(descriptor_->file(), options_) ? "" : "Lite";
format(
"return ::$proto_ns$::internal::MergePartialFromCodedStream$1$(\n"
" this, ::$tablename$::schema[\n"
" $classname$::kIndexInFileMessages], input);\n",
lite);
format.Outdent();
format("}\n");
format("#endif // $GOOGLE_PROTOBUF$_ENABLE_EXPERIMENTAL_PARSER\n");
return;
}
if (SupportsArenas(descriptor_)) {
for (auto field : ordered_fields) {
const FieldGenerator& field_generator = field_generators_.get(field);
if (field_generator.MergeFromCodedStreamNeedsArena()) {
format(" ::$proto_ns$::Arena* arena = GetArenaNoVirtual();\n");
break;
}
}
}
format(
"#define DO_(EXPRESSION) if "
"(!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure\n"
" $uint32$ tag;\n");
if (!UseUnknownFieldSet(descriptor_->file(), options_)) {
format(
" ::$proto_ns$::internal::LiteUnknownFieldSetter "
"unknown_fields_setter(\n"
" &_internal_metadata_);\n"
" ::$proto_ns$::io::StringOutputStream unknown_fields_output(\n"
" unknown_fields_setter.buffer());\n"
" ::$proto_ns$::io::CodedOutputStream unknown_fields_stream(\n"
" &unknown_fields_output, false);\n");
}
format(" // @@protoc_insertion_point(parse_start:$full_name$)\n");
format.Indent();
format("for (;;) {\n");
format.Indent();
// To calculate the maximum tag to expect, we look at the highest-numbered
// field. We need to be prepared to handle more than one wire type if that
// field is a packable repeated field, so to simplify things we assume the
// highest possible wire type of 5.
uint32 maxtag =
ordered_fields.empty() ? 0 : ordered_fields.back()->number() * 8 + 5;
const int kCutoff0 = 127; // fits in 1-byte varint
const int kCutoff1 = (127 << 7) + 127; // fits in 2-byte varint
// We need to capture the last tag when parsing if this is a Group type, as
// our caller will verify (via CodedInputStream::LastTagWas) that the correct
// closing tag was received.
bool capture_last_tag = false;
const Descriptor* parent = descriptor_->containing_type();
if (parent) {
for (auto field : FieldRange(parent)) {
if (field->type() == FieldDescriptor::TYPE_GROUP &&
field->message_type() == descriptor_) {
capture_last_tag = true;
break;
}
}
for (int i = 0; i < parent->extension_count(); i++) {
const FieldDescriptor* field = parent->extension(i);
if (field->type() == FieldDescriptor::TYPE_GROUP &&
field->message_type() == descriptor_) {
capture_last_tag = true;
break;
}
}
}
for (int i = 0; i < descriptor_->file()->extension_count(); i++) {
const FieldDescriptor* field = descriptor_->file()->extension(i);
if (field->type() == FieldDescriptor::TYPE_GROUP &&
field->message_type() == descriptor_) {
capture_last_tag = true;
break;
}
}
format(
"::std::pair<$uint32$, bool> p = "
"input->ReadTagWithCutoffNoLastTag($1$u);\n"
"tag = p.first;\n"
"if (!p.second) goto handle_unusual;\n",
maxtag <= kCutoff0 ? kCutoff0 : (maxtag <= kCutoff1 ? kCutoff1 : maxtag));
if (descriptor_->field_count() > 0) {
// We don't even want to print the switch() if we have no fields because
// MSVC dislikes switch() statements that contain only a default value.
// Note: If we just switched on the tag rather than the field number, we
// could avoid the need for the if() to check the wire type at the beginning
// of each case. However, this is actually a bit slower in practice as it
// creates a jump table that is 8x larger and sparser, and meanwhile the
// if()s are highly predictable.
//
// Historically, we inserted checks to peek at the next tag on the wire and
// jump directly to the next case statement. While this avoids the jump
// table that the switch uses, it greatly increases code size (20-60%) and
// inserts branches that may fail (especially for real world protos that
// interleave--in field number order--hot and cold fields). Loadtests
// confirmed that removing this optimization is performance neutral.
if (num_weak_fields_ > 0) {
format("uint32 weak_offset;\n");
}
format(
"switch (::$proto_ns$::internal::WireFormatLite::"
"GetTagFieldNumber(tag)) {\n");
format.Indent();
for (auto field : ordered_fields) {
PrintFieldComment(format, field);
if (IsWeak(field, options_)) {
format(
"case $1$:\n"
" weak_offset = offsetof($classname$DefaultTypeInternal, $2$_);\n"
" goto handle_weak_field_map;\n",
field->number(), FieldName(field));
continue;
}
format("case $1$: {\n", field->number());
format.Indent();
const FieldGenerator& field_generator = field_generators_.get(field);
// Emit code to parse the common, expected case.
// MSVC is warning about truncating constant in the static_cast so
// we truncate the tag explicitly.
format("if (static_cast< $uint8$>(tag) == ($1$ & 0xFF)) {\n",
WireFormat::MakeTag(field));
format.Indent();
if (field->is_packed()) {
field_generator.GenerateMergeFromCodedStreamWithPacking(printer);
} else {
field_generator.GenerateMergeFromCodedStream(printer);
}
format.Outdent();
// Emit code to parse unexpectedly packed or unpacked values.
if (field->is_packed()) {
internal::WireFormatLite::WireType wiretype =
WireFormat::WireTypeForFieldType(field->type());
const uint32 tag =
internal::WireFormatLite::MakeTag(field->number(), wiretype);
format("} else if (static_cast< $uint8$>(tag) == ($1$ & 0xFF)) {\n",
tag);
format.Indent();
field_generator.GenerateMergeFromCodedStream(printer);
format.Outdent();
} else if (field->is_packable() && !field->is_packed()) {
internal::WireFormatLite::WireType wiretype =
internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED;
const uint32 tag =
internal::WireFormatLite::MakeTag(field->number(), wiretype);
format("} else if (static_cast< $uint8$>(tag) == ($1$ & 0xFF)) {\n",
tag);
format.Indent();
field_generator.GenerateMergeFromCodedStreamWithPacking(printer);
format.Outdent();
}
format(
"} else {\n"
" goto handle_unusual;\n"
"}\n");
format("break;\n");
format.Outdent();
format("}\n\n");
}
if (num_weak_fields_ > 0) {
format("handle_weak_field_map: {\n");
format.Indent();
format(
"if ((tag & 0x7) != 2) goto handle_unusual;\n"
"DO_(_weak_field_map_.ReadMessage(input, tag >> 3,\n"
" &_$classname$_default_instance_, weak_offset));\n");
format("break;\n");
format.Outdent();
format("}\n\n");
}
format("default: {\n");
format.Indent();
}
format.Outdent();
format("handle_unusual:\n");
format.Indent();
// If tag is 0 or an end-group tag then this must be the end of the message.
if (capture_last_tag) {
format(
"if (tag == 0 ||\n"
" ::$proto_ns$::internal::WireFormatLite::GetTagWireType(tag) ==\n"
" ::$proto_ns$::internal::WireFormatLite::WIRETYPE_END_GROUP) {\n"
" input->SetLastTag(tag);\n"
" goto success;\n"
"}\n");
} else {
format(
"if (tag == 0) {\n"
" goto success;\n"
"}\n");
}
// Handle extension ranges.
if (descriptor_->extension_range_count() > 0) {
format("if (");
for (int i = 0; i < descriptor_->extension_range_count(); i++) {
const Descriptor::ExtensionRange* range = descriptor_->extension_range(i);
if (i > 0) format(" ||\n ");
uint32 start_tag = WireFormatLite::MakeTag(
range->start, static_cast<WireFormatLite::WireType>(0));
uint32 end_tag = WireFormatLite::MakeTag(
range->end, static_cast<WireFormatLite::WireType>(0));
if (range->end > FieldDescriptor::kMaxNumber) {
format("($1$u <= tag)", start_tag);
} else {
format("($1$u <= tag && tag < $2$u)", start_tag, end_tag);
}
}
format(") {\n");
if (UseUnknownFieldSet(descriptor_->file(), options_)) {
format(
" DO_(_extensions_.ParseField(tag, input,\n"
" internal_default_instance(),\n"
" $mutable_unknown_fields$));\n");
} else {
format(
" DO_(_extensions_.ParseField(tag, input,\n"
" internal_default_instance(),\n"
" &unknown_fields_stream));\n");
}
format(
" continue;\n"
"}\n");
}
// We really don't recognize this tag. Skip it.
if (UseUnknownFieldSet(descriptor_->file(), options_)) {
format(
"DO_(::$proto_ns$::internal::WireFormat::SkipField(\n"
" input, tag, $mutable_unknown_fields$));\n");
} else {
format(
"DO_(::$proto_ns$::internal::WireFormatLite::SkipField(\n"
" input, tag, &unknown_fields_stream));\n");
}
if (descriptor_->field_count() > 0) {
format("break;\n");
format.Outdent();
format("}\n"); // default:
format.Outdent();
format("}\n"); // switch
}
format.Outdent();
format.Outdent();
format(
" }\n" // for (;;)
"success:\n"
" // @@protoc_insertion_point(parse_success:$full_name$)\n"
" return true;\n"
"failure:\n"
" // @@protoc_insertion_point(parse_failure:$full_name$)\n"
" return false;\n"
"#undef DO_\n"
"}\n");
format("#endif // $GOOGLE_PROTOBUF$_ENABLE_EXPERIMENTAL_PARSER\n");
}
void MessageGenerator::GenerateSerializeOneofFields(
@ -3715,12 +3426,13 @@ void MessageGenerator::GenerateSerializeOneofFields(
format("switch ($1$_case()) {\n", oneof->name());
format.Indent();
for (auto field : fields) {
format("case k$1$:\n", UnderscoresToCamelCase(field->name(), true));
format("case k$1$: {\n", UnderscoresToCamelCase(field->name(), true));
format.Indent();
field_generators_.get(field).GenerateSerializeWithCachedSizesToArray(
printer);
format("break;\n");
format.Outdent();
format("}\n");
}
format.Outdent();
// Doing nothing is an option.

151
src/google/protobuf/compiler/cpp/cpp_message_field.cc
View File

@ -66,8 +66,8 @@ void SetMessageVariables(const FieldDescriptor* descriptor,
QualifiedDefaultInstancePtr(descriptor->message_type(), options);
(*variables)["type_reference_function"] =
implicit_weak
? (" " + ReferenceFunctionName(descriptor->message_type(), options) +
"();\n")
? (" " + (*variables)["proto_ns"] + "::internal::StrongReference(" +
(*variables)["type_default_instance"] + ");\n")
: "";
// NOTE: Escaped here to unblock proto1->proto2 migration.
// TODO(liujisi): Extend this to apply for other conflicting methods.
@ -108,7 +108,11 @@ void MessageFieldGenerator::GenerateAccessorDeclarations(
"$deprecated_attr$$type$* ${1$$release_name$$}$();\n"
"$deprecated_attr$$type$* ${1$mutable_$name$$}$();\n"
"$deprecated_attr$void ${1$set_allocated_$name$$}$"
"($type$* $name$);\n",
"($type$* $name$);\n"
"private:\n"
"const $type$& ${1$_internal_$name$$}$() const;\n"
"$type$* ${1$_internal_mutable_$name$$}$();\n"
"public:\n",
descriptor_);
if (SupportsArenas(descriptor_)) {
format(
@ -149,13 +153,16 @@ void MessageFieldGenerator::GenerateInlineAccessorDefinitions(
io::Printer* printer) const {
Formatter format(printer, variables_);
format(
"inline const $type$& $classname$::$name$() const {\n"
"$annotate_accessor$"
"inline const $type$& $classname$::_internal_$name$() const {\n"
"$type_reference_function$"
" const $type$* p = $casted_member$;\n"
" // @@protoc_insertion_point(field_get:$full_name$)\n"
" return p != nullptr ? *p : *reinterpret_cast<const $type$*>(\n"
" &$type_default_instance$);\n"
"}\n"
"inline const $type$& $classname$::$name$() const {\n"
"$annotate_accessor$"
" // @@protoc_insertion_point(field_get:$full_name$)\n"
" return _internal_$name$();\n"
"}\n");
if (SupportsArenas(descriptor_)) {
@ -182,8 +189,7 @@ void MessageFieldGenerator::GenerateInlineAccessorDefinitions(
"}\n");
format(
"inline $type$* $classname$::mutable_$name$() {\n"
"$annotate_accessor$"
"inline $type$* $classname$::_internal_mutable_$name$() {\n"
"$type_reference_function$"
" $set_hasbit$\n"
" if ($name$_ == nullptr) {\n"
@ -195,8 +201,12 @@ void MessageFieldGenerator::GenerateInlineAccessorDefinitions(
}
format(
" }\n"
" // @@protoc_insertion_point(field_mutable:$full_name$)\n"
" return $casted_member$;\n"
"}\n"
"inline $type$* $classname$::mutable_$name$() {\n"
"$annotate_accessor$"
" // @@protoc_insertion_point(field_mutable:$full_name$)\n"
" return _internal_mutable_$name$();\n"
"}\n");
// We handle the most common case inline, and delegate less common cases to
@ -381,7 +391,9 @@ void MessageFieldGenerator::GenerateMergingCode(io::Printer* printer) const {
"_Internal::mutable_$name$(this)->CheckTypeAndMergeFrom(\n"
" _Internal::$name$(&from));\n");
} else {
format("mutable_$name$()->$type$::MergeFrom(from.$name$());\n");
format(
"_internal_mutable_$name$()->$type$::MergeFrom(from._internal_$name$())"
";\n");
}
}
@ -413,31 +425,13 @@ void MessageFieldGenerator::GenerateCopyConstructorCode(
io::Printer* printer) const {
Formatter format(printer, variables_);
format(
"if (from.has_$name$()) {\n"
"if (from._internal_has_$name$()) {\n"
" $name$_ = new $type$(*from.$name$_);\n"
"} else {\n"
" $name$_ = nullptr;\n"
"}\n");
}
void MessageFieldGenerator::GenerateMergeFromCodedStream(
io::Printer* printer) const {
Formatter format(printer, variables_);
if (implicit_weak_field_) {
format(
"DO_(::$proto_ns$::internal::WireFormatLite::ReadMessage(\n"
" input, _Internal::mutable_$name$(this)));\n");
} else if (descriptor_->type() == FieldDescriptor::TYPE_MESSAGE) {
format(
"DO_(::$proto_ns$::internal::WireFormatLite::ReadMessage(\n"
" input, mutable_$name$()));\n");
} else {
format(
"DO_(::$proto_ns$::internal::WireFormatLite::ReadGroup(\n"
" $number$, input, mutable_$name$()));\n");
}
}
void MessageFieldGenerator::GenerateSerializeWithCachedSizesToArray(
io::Printer* printer) const {
Formatter format(printer, variables_);
@ -528,12 +522,15 @@ void MessageOneofFieldGenerator::GenerateInlineAccessorDefinitions(
"}\n");
format(
"inline const $type$& $classname$::_internal_$name$() const {\n"
" return _internal_has_$name$()\n"
" ? *$field_member$\n"
" : *reinterpret_cast< $type$*>(&$type_default_instance$);\n"
"}\n"
"inline const $type$& $classname$::$name$() const {\n"
"$annotate_accessor$"
" // @@protoc_insertion_point(field_get:$full_name$)\n"
" return has_$name$()\n"
" ? *$field_member$\n"
" : *reinterpret_cast< $type$*>(&$type_default_instance$);\n"
" return _internal_$name$();\n"
"}\n");
if (SupportsArenas(descriptor_)) {
@ -568,16 +565,19 @@ void MessageOneofFieldGenerator::GenerateInlineAccessorDefinitions(
}
format(
"inline $type$* $classname$::mutable_$name$() {\n"
"$annotate_accessor$"
" if (!has_$name$()) {\n"
"inline $type$* $classname$::_internal_mutable_$name$() {\n"
" if (!_internal_has_$name$()) {\n"
" clear_$oneof_name$();\n"
" set_has_$name$();\n"
" $field_member$ = CreateMaybeMessage< $type$ >(\n"
" GetArenaNoVirtual());\n"
" }\n"
" // @@protoc_insertion_point(field_mutable:$full_name$)\n"
" return $field_member$;\n"
"}\n"
"inline $type$* $classname$::mutable_$name$() {\n"
"$annotate_accessor$"
" // @@protoc_insertion_point(field_mutable:$full_name$)\n"
" return _internal_mutable_$name$();\n"
"}\n");
}
@ -646,6 +646,10 @@ void RepeatedMessageFieldGenerator::GenerateAccessorDeclarations(
"$deprecated_attr$$type$* ${1$mutable_$name$$}$(int index);\n"
"$deprecated_attr$::$proto_ns$::RepeatedPtrField< $type$ >*\n"
" ${1$mutable_$name$$}$();\n"
"private:\n"
"const $type$& ${1$_internal_$name$$}$(int index) const;\n"
"$type$* ${1$_internal_add_$name$$}$();\n"
"public:\n"
"$deprecated_attr$const $type$& ${1$$name$$}$(int index) const;\n"
"$deprecated_attr$$type$* ${1$add_$name$$}$();\n"
"$deprecated_attr$const ::$proto_ns$::RepeatedPtrField< $type$ >&\n"
@ -676,27 +680,33 @@ void RepeatedMessageFieldGenerator::GenerateInlineAccessorDefinitions(
if (options_.safe_boundary_check) {
format(
"inline const $type$& $classname$::$name$(int index) const {\n"
"$annotate_accessor$"
" // @@protoc_insertion_point(field_get:$full_name$)\n"
"inline const $type$& $classname$::_internal_$name$(int index) const "
"{\n"
" return $name$_$weak$.InternalCheckedGet(index,\n"
" *reinterpret_cast<const $type$*>(&$type_default_instance$));\n"
"}\n");
} else {
format(
"inline const $type$& $classname$::$name$(int index) const {\n"
"$annotate_accessor$"
" // @@protoc_insertion_point(field_get:$full_name$)\n"
"inline const $type$& $classname$::_internal_$name$(int index) const "
"{\n"
"$type_reference_function$"
" return $name$_$weak$.Get(index);\n"
"}\n");
}
format(
"inline const $type$& $classname$::$name$(int index) const {\n"
"$annotate_accessor$"
" // @@protoc_insertion_point(field_get:$full_name$)\n"
" return _internal_$name$(index);\n"
"}\n"
"inline $type$* $classname$::_internal_add_$name$() {\n"
" return $name$_$weak$.Add();\n"
"}\n"
"inline $type$* $classname$::add_$name$() {\n"
"$annotate_accessor$"
" // @@protoc_insertion_point(field_add:$full_name$)\n"
" return $name$_$weak$.Add();\n"
" return _internal_add_$name$();\n"
"}\n");
format(
@ -732,47 +742,38 @@ void RepeatedMessageFieldGenerator::GenerateConstructorCode(
// Not needed for repeated fields.
}
void RepeatedMessageFieldGenerator::GenerateMergeFromCodedStream(
io::Printer* printer) const {
Formatter format(printer, variables_);
if (descriptor_->type() == FieldDescriptor::TYPE_MESSAGE) {
if (implicit_weak_field_) {
format(
"DO_(::$proto_ns$::internal::WireFormatLite::"
"ReadMessage(input, $name$_.AddWeak(\n"
" reinterpret_cast<const ::$proto_ns$::MessageLite*>(\n"
" $type_default_instance_ptr$))));\n");
} else {
format(
"DO_(::$proto_ns$::internal::WireFormatLite::"
"ReadMessage(\n"
" input, add_$name$()));\n");
}
} else {
format(
"DO_(::$proto_ns$::internal::WireFormatLite::"
"ReadGroup($number$, input, add_$name$()));\n");
}
}
void RepeatedMessageFieldGenerator::GenerateSerializeWithCachedSizesToArray(
io::Printer* printer) const {
Formatter format(printer, variables_);
format(
"for (auto it = this->$name$_.pointer_begin(),\n"
" end = this->$name$_.pointer_end(); it < end; ++it) {\n"
" stream->EnsureSpace(&target);\n"
" target = ::$proto_ns$::internal::WireFormatLite::\n"
" InternalWrite$declared_type$ToArray($number$, **it, target, "
"stream);\n"
"}\n");
if (implicit_weak_field_) {
format(
"for (auto it = this->$name$_.pointer_begin(),\n"
" end = this->$name$_.pointer_end(); it < end; ++it) {\n"
" stream->EnsureSpace(&target);\n"
" target = ::$proto_ns$::internal::WireFormatLite::\n"
" InternalWrite$declared_type$ToArray($number$, **it, target, "
"stream);\n"
"}\n");
} else {
format(
"for (unsigned int i = 0,\n"
" n = static_cast<unsigned int>(this->_internal_$name$_size()); i < "
"n; i++) "
"{\n"
" stream->EnsureSpace(&target);\n"
" target = ::$proto_ns$::internal::WireFormatLite::\n"
" InternalWrite$declared_type$ToArray($number$, "
"this->_internal_$name$(i), target, "
"stream);\n"
"}\n");
}
}
void RepeatedMessageFieldGenerator::GenerateByteSize(
io::Printer* printer) const {
Formatter format(printer, variables_);
format(
"total_size += $tag_size$UL * this->$name$_size();\n"
"total_size += $tag_size$UL * this->_internal_$name$_size();\n"
"for (const auto& msg : this->$name$_) {\n"
" total_size +=\n"
" ::$proto_ns$::internal::WireFormatLite::$declared_type$Size(msg);\n"

2
src/google/protobuf/compiler/cpp/cpp_message_field.h
View File

@ -66,7 +66,6 @@ class MessageFieldGenerator : public FieldGenerator {
void GenerateDestructorCode(io::Printer* printer) const;
void GenerateConstructorCode(io::Printer* printer) const;
void GenerateCopyConstructorCode(io::Printer* printer) const;
void GenerateMergeFromCodedStream(io::Printer* printer) const;
void GenerateSerializeWithCachedSizesToArray(io::Printer* printer) const;
void GenerateByteSize(io::Printer* printer) const;
@ -116,7 +115,6 @@ class RepeatedMessageFieldGenerator : public FieldGenerator {
void GenerateSwappingCode(io::Printer* printer) const;
void GenerateConstructorCode(io::Printer* printer) const;
void GenerateCopyConstructorCode(io::Printer* printer) const {}
void GenerateMergeFromCodedStream(io::Printer* printer) const;
void GenerateSerializeWithCachedSizesToArray(io::Printer* printer) const;
void GenerateByteSize(io::Printer* printer) const;

134
src/google/protobuf/compiler/cpp/cpp_primitive_field.cc
View File

@ -136,7 +136,11 @@ void PrimitiveFieldGenerator::GenerateAccessorDeclarations(
Formatter format(printer, variables_);
format(
"$deprecated_attr$$type$ ${1$$name$$}$() const;\n"
"$deprecated_attr$void ${1$set_$name$$}$($type$ value);\n",
"$deprecated_attr$void ${1$set_$name$$}$($type$ value);\n"
"private:\n"
"$type$ ${1$_internal_$name$$}$() const;\n"
"void ${1$_internal_set_$name$$}$($type$ value);\n"
"public:\n",
descriptor_);
}
@ -144,15 +148,21 @@ void PrimitiveFieldGenerator::GenerateInlineAccessorDefinitions(
io::Printer* printer) const {
Formatter format(printer, variables_);
format(
"inline $type$ $classname$::_internal_$name$() const {\n"
" return $name$_;\n"
"}\n"
"inline $type$ $classname$::$name$() const {\n"
"$annotate_accessor$"
" // @@protoc_insertion_point(field_get:$full_name$)\n"
" return $name$_;\n"
" return _internal_$name$();\n"
"}\n"
"inline void $classname$::_internal_set_$name$($type$ value) {\n"
" $set_hasbit$\n"
" $name$_ = value;\n"
"}\n"
"inline void $classname$::set_$name$($type$ value) {\n"
"$annotate_accessor$"
" $set_hasbit$\n"
" $name$_ = value;\n"
" _internal_set_$name$(value);\n"
" // @@protoc_insertion_point(field_set:$full_name$)\n"
"}\n");
}
@ -164,7 +174,7 @@ void PrimitiveFieldGenerator::GenerateClearingCode(io::Printer* printer) const {
void PrimitiveFieldGenerator::GenerateMergingCode(io::Printer* printer) const {
Formatter format(printer, variables_);
format("set_$name$(from.$name$());\n");
format("_internal_set_$name$(from._internal_$name$());\n");
}
void PrimitiveFieldGenerator::GenerateSwappingCode(io::Printer* printer) const {
@ -184,17 +194,6 @@ void PrimitiveFieldGenerator::GenerateCopyConstructorCode(
format("$name$_ = from.$name$_;\n");
}
void PrimitiveFieldGenerator::GenerateMergeFromCodedStream(
io::Printer* printer) const {
Formatter format(printer, variables_);
format(
"$set_hasbit_io$\n"
"DO_((::$proto_ns$::internal::WireFormatLite::ReadPrimitive<\n"
" $type$, "
"::$proto_ns$::internal::WireFormatLite::$wire_format_field_type$>(\n"
" input, &$name$_)));\n");
}
void PrimitiveFieldGenerator::GenerateSerializeWithCachedSizesToArray(
io::Printer* printer) const {
Formatter format(printer, variables_);
@ -202,7 +201,7 @@ void PrimitiveFieldGenerator::GenerateSerializeWithCachedSizesToArray(
"stream->EnsureSpace(&target);\n"
"target = "
"::$proto_ns$::internal::WireFormatLite::Write$declared_type$ToArray("
"$number$, this->$name$(), target);\n");
"$number$, this->_internal_$name$(), target);\n");
}
void PrimitiveFieldGenerator::GenerateByteSize(io::Printer* printer) const {
@ -212,7 +211,7 @@ void PrimitiveFieldGenerator::GenerateByteSize(io::Printer* printer) const {
format(
"total_size += $tag_size$ +\n"
" ::$proto_ns$::internal::WireFormatLite::$declared_type$Size(\n"
" this->$name$());\n");
" this->_internal_$name$());\n");
} else {
format("total_size += $tag_size$ + $fixed_size$;\n");
}
@ -232,21 +231,27 @@ void PrimitiveOneofFieldGenerator::GenerateInlineAccessorDefinitions(
io::Printer* printer) const {
Formatter format(printer, variables_);
format(
"inline $type$ $classname$::$name$() const {\n"
"$annotate_accessor$"
" // @@protoc_insertion_point(field_get:$full_name$)\n"
" if (has_$name$()) {\n"
"inline $type$ $classname$::_internal_$name$() const {\n"
" if (_internal_has_$name$()) {\n"
" return $field_member$;\n"
" }\n"
" return $default$;\n"
"}\n"
"inline void $classname$::set_$name$($type$ value) {\n"
"$annotate_accessor$"
" if (!has_$name$()) {\n"
"inline void $classname$::_internal_set_$name$($type$ value) {\n"
" if (!_internal_has_$name$()) {\n"
" clear_$oneof_name$();\n"
" set_has_$name$();\n"
" }\n"
" $field_member$ = value;\n"
"}\n"
"inline $type$ $classname$::$name$() const {\n"
"$annotate_accessor$"
" // @@protoc_insertion_point(field_get:$full_name$)\n"
" return _internal_$name$();\n"
"}\n"
"inline void $classname$::set_$name$($type$ value) {\n"
"$annotate_accessor$"
" _internal_set_$name$(value);\n"
" // @@protoc_insertion_point(field_set:$full_name$)\n"
"}\n");
}
@ -268,18 +273,6 @@ void PrimitiveOneofFieldGenerator::GenerateConstructorCode(
format("$ns$::_$classname$_default_instance_.$name$_ = $default$;\n");
}
void PrimitiveOneofFieldGenerator::GenerateMergeFromCodedStream(
io::Printer* printer) const {
Formatter format(printer, variables_);
format(
"clear_$oneof_name$();\n"
"DO_((::$proto_ns$::internal::WireFormatLite::ReadPrimitive<\n"
" $type$, "
"::$proto_ns$::internal::WireFormatLite::$wire_format_field_type$>(\n"
" input, &$field_member$)));\n"
"set_has_$name$();\n");
}
// ===================================================================
RepeatedPrimitiveFieldGenerator::RepeatedPrimitiveFieldGenerator(
@ -312,6 +305,14 @@ void RepeatedPrimitiveFieldGenerator::GenerateAccessorDeclarations(
io::Printer* printer) const {
Formatter format(printer, variables_);
format(
"private:\n"
"$type$ ${1$_internal_$name$$}$(int index) const;\n"
"const ::$proto_ns$::RepeatedField< $type$ >&\n"
" ${1$_internal_$name$$}$() const;\n"
"void ${1$_internal_add_$name$$}$($type$ value);\n"
"::$proto_ns$::RepeatedField< $type$ >*\n"
" ${1$_internal_mutable_$name$$}$();\n"
"public:\n"
"$deprecated_attr$$type$ ${1$$name$$}$(int index) const;\n"
"$deprecated_attr$void ${1$set_$name$$}$(int index, $type$ value);\n"
"$deprecated_attr$void ${1$add_$name$$}$($type$ value);\n"
@ -326,32 +327,46 @@ void RepeatedPrimitiveFieldGenerator::GenerateInlineAccessorDefinitions(
io::Printer* printer) const {
Formatter format(printer, variables_);
format(
"inline $type$ $classname$::_internal_$name$(int index) const {\n"
" return $name$_.Get(index);\n"
"}\n"
"inline $type$ $classname$::$name$(int index) const {\n"
"$annotate_accessor$"
" // @@protoc_insertion_point(field_get:$full_name$)\n"
" return $name$_.Get(index);\n"
" return _internal_$name$(index);\n"
"}\n"
"inline void $classname$::set_$name$(int index, $type$ value) {\n"
"$annotate_accessor$"
" $name$_.Set(index, value);\n"
" // @@protoc_insertion_point(field_set:$full_name$)\n"
"}\n"
"inline void $classname$::_internal_add_$name$($type$ value) {\n"
" $name$_.Add(value);\n"
"}\n"
"inline void $classname$::add_$name$($type$ value) {\n"
"$annotate_accessor$"
" $name$_.Add(value);\n"
" _internal_add_$name$(value);\n"
" // @@protoc_insertion_point(field_add:$full_name$)\n"
"}\n"
"inline const ::$proto_ns$::RepeatedField< $type$ >&\n"
"$classname$::_internal_$name$() const {\n"
" return $name$_;\n"
"}\n"
"inline const ::$proto_ns$::RepeatedField< $type$ >&\n"
"$classname$::$name$() const {\n"
"$annotate_accessor$"
" // @@protoc_insertion_point(field_list:$full_name$)\n"
" return $name$_;\n"
" return _internal_$name$();\n"
"}\n"
"inline ::$proto_ns$::RepeatedField< $type$ >*\n"
"$classname$::_internal_mutable_$name$() {\n"
" return &$name$_;\n"
"}\n"
"inline ::$proto_ns$::RepeatedField< $type$ >*\n"
"$classname$::mutable_$name$() {\n"
"$annotate_accessor$"
" // @@protoc_insertion_point(field_mutable_list:$full_name$)\n"
" return &$name$_;\n"
" return _internal_mutable_$name$();\n"
"}\n");
}
@ -384,34 +399,15 @@ void RepeatedPrimitiveFieldGenerator::GenerateCopyConstructorCode(
format("$name$_.CopyFrom(from.$name$_);\n");
}
void RepeatedPrimitiveFieldGenerator::GenerateMergeFromCodedStream(
io::Printer* printer) const {
Formatter format(printer, variables_);
format(
"DO_((::$proto_ns$::internal::WireFormatLite::$repeated_reader$<\n"
" $type$, "
"::$proto_ns$::internal::WireFormatLite::$wire_format_field_type$>(\n"
" $tag_size$, $tag$u, input, this->mutable_$name$())));\n");
}
void RepeatedPrimitiveFieldGenerator::GenerateMergeFromCodedStreamWithPacking(
io::Printer* printer) const {
Formatter format(printer, variables_);
format(
"DO_((::$proto_ns$::internal::WireFormatLite::$packed_reader$<\n"
" $type$, "
"::$proto_ns$::internal::WireFormatLite::$wire_format_field_type$>(\n"
" input, this->mutable_$name$())));\n");
}
void RepeatedPrimitiveFieldGenerator::GenerateSerializeWithCachedSizesToArray(
io::Printer* printer) const {
Formatter format(printer, variables_);
if (descriptor_->is_packed()) {
if (FixedSize(descriptor_->type()) > 0) {
format(
"if (this->$name$_size() > 0) {\n"
" target = stream->WriteFixedPacked($number$, $name$_, target);\n"
"if (this->_internal_$name$_size() > 0) {\n"
" target = stream->WriteFixedPacked($number$, _internal_$name$(), "
"target);\n"
"}\n");
} else {
format(
@ -420,16 +416,17 @@ void RepeatedPrimitiveFieldGenerator::GenerateSerializeWithCachedSizesToArray(
"_$name$_cached_byte_size_.load(std::memory_order_relaxed);\n"
" if (byte_size > 0) {\n"
" target = stream->Write$declared_type$Packed(\n"
" $number$, $name$_, byte_size, target);\n"
" $number$, _internal_$name$(), byte_size, target);\n"
" }\n"
"}\n");
}
} else {
format(
"for (const auto& x : this->$name$()) {\n"
"for (int i = 0, n = this->_internal_$name$_size(); i < n; i++) {\n"
" stream->EnsureSpace(&target);\n"
" target = ::$proto_ns$::internal::WireFormatLite::"
"Write$declared_type$ToArray($number$, x, target);\n"
"Write$declared_type$ToArray($number$, this->_internal_$name$(i), "
"target);\n"
"}\n");
}
}
@ -446,7 +443,8 @@ void RepeatedPrimitiveFieldGenerator::GenerateByteSize(
" $declared_type$Size(this->$name$_);\n");
} else {
format(
"unsigned int count = static_cast<unsigned int>(this->$name$_size());\n"
"unsigned int count = static_cast<unsigned "
"int>(this->_internal_$name$_size());\n"
"size_t data_size = $fixed_size$UL * count;\n");
}
@ -465,7 +463,7 @@ void RepeatedPrimitiveFieldGenerator::GenerateByteSize(
format(
"total_size += $tag_size$ *\n"
" "
"::$proto_ns$::internal::FromIntSize(this->$name$_size());\n"
"::$proto_ns$::internal::FromIntSize(this->_internal_$name$_size());\n"
"total_size += data_size;\n");
}
format.Outdent();

4
src/google/protobuf/compiler/cpp/cpp_primitive_field.h
View File

@ -59,7 +59,6 @@ class PrimitiveFieldGenerator : public FieldGenerator {
void GenerateSwappingCode(io::Printer* printer) const;
void GenerateConstructorCode(io::Printer* printer) const;
void GenerateCopyConstructorCode(io::Printer* printer) const;
void GenerateMergeFromCodedStream(io::Printer* printer) const;
void GenerateSerializeWithCachedSizesToArray(io::Printer* printer) const;
void GenerateByteSize(io::Printer* printer) const;
@ -78,7 +77,6 @@ class PrimitiveOneofFieldGenerator : public PrimitiveFieldGenerator {
void GenerateClearingCode(io::Printer* printer) const;
void GenerateSwappingCode(io::Printer* printer) const;
void GenerateConstructorCode(io::Printer* printer) const;
void GenerateMergeFromCodedStream(io::Printer* printer) const;
private:
GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(PrimitiveOneofFieldGenerator);
@ -99,8 +97,6 @@ class RepeatedPrimitiveFieldGenerator : public FieldGenerator {
void GenerateSwappingCode(io::Printer* printer) const;
void GenerateConstructorCode(io::Printer* printer) const;
void GenerateCopyConstructorCode(io::Printer* printer) const;
void GenerateMergeFromCodedStream(io::Printer* printer) const;
void GenerateMergeFromCodedStreamWithPacking(io::Printer* printer) const;
void GenerateSerializeWithCachedSizesToArray(io::Printer* printer) const;
void GenerateByteSize(io::Printer* printer) const;

154
src/google/protobuf/compiler/cpp/cpp_string_field.cc
View File

@ -602,44 +602,6 @@ void StringFieldGenerator::GenerateDefaultInstanceAllocator(
}
}
void StringFieldGenerator::GenerateMergeFromCodedStream(
io::Printer* printer) const {
Formatter format(printer, variables_);
// The google3 version of proto2 has ArenaStrings and parses into them
// directly, but for the open-source release, we always parse into std::string
// instances. Note that for lite, we do similarly to the open source release
// and use std::string, not ArenaString.
if (!options_.opensource_runtime && !inlined_ &&
SupportsArenas(descriptor_) && !lite_) {
// If arena != NULL, the current string is either an ArenaString (no
// destructor necessary) or a materialized std::string (and is on the
// Arena's destructor list). No call to ArenaStringPtr::Destroy is needed.
format(
"if (arena != nullptr) {\n"
" ::$proto_ns$::internal::TaggedPtr<std::string> str =\n"
" ::$proto_ns$::internal::ReadArenaString(input, arena);\n"
" DO_(!str.IsNull());\n"
" $set_hasbit_io$\n"
" $name$_.UnsafeSetTaggedPointer(str);\n"
"} else {\n"
" DO_(::$proto_ns$::internal::WireFormatLite::Read$declared_type$(\n"
" input, this->_internal_mutable_$name$()));\n"
"}\n");
} else {
format(
"DO_(::$proto_ns$::internal::WireFormatLite::Read$declared_type$(\n"
" input, this->_internal_mutable_$name$()));\n");
}
if (descriptor_->type() == FieldDescriptor::TYPE_STRING) {
GenerateUtf8CheckCodeForString(
descriptor_, options_, true,
"this->_internal_$name$().data(), "
"static_cast<int>(this->_internal_$name$().length()),\n",
format);
}
}
bool StringFieldGenerator::MergeFromCodedStreamNeedsArena() const {
return !lite_ && !inlined_ && !options_.opensource_runtime;
}
@ -682,10 +644,6 @@ StringOneofFieldGenerator::StringOneofFieldGenerator(
variables_["field_name"] = UnderscoresToCamelCase(descriptor->name(), true);
variables_["oneof_index"] =
StrCat(descriptor->containing_oneof()->index());
// has_$name$() for oneof fields is private if has_bit is not present. In that
// case, use _has_$name$() instead of _internal_has_$name$().
variables_["internal"] =
HasFieldPresence(descriptor->file()) ? "_internal_" : "";
}
StringOneofFieldGenerator::~StringOneofFieldGenerator() {}
@ -712,14 +670,14 @@ void StringOneofFieldGenerator::GenerateInlineAccessorDefinitions(
if (SupportsArenas(descriptor_)) {
format(
"inline const std::string& $classname$::_internal_$name$() const {\n"
" if ($internal$has_$name$()) {\n"
" if (_internal_has_$name$()) {\n"
" return $field_member$.Get();\n"
" }\n"
" return *$default_variable$;\n"
"}\n"
"inline void $classname$::_internal_set_$name$(const std::string& "
"value) {\n"
" if (!$internal$has_$name$()) {\n"
" if (!_internal_has_$name$()) {\n"
" clear_$oneof_name$();\n"
" set_has_$name$();\n"
" $field_member$.UnsafeSetDefault($default_variable$);\n"
@ -730,7 +688,7 @@ void StringOneofFieldGenerator::GenerateInlineAccessorDefinitions(
"inline void $classname$::set_$name$(std::string&& value) {\n"
"$annotate_accessor$"
" // @@protoc_insertion_point(field_set:$full_name$)\n"
" if (!has_$name$()) {\n"
" if (!_internal_has_$name$()) {\n"
" clear_$oneof_name$();\n"
" set_has_$name$();\n"
" $field_member$.UnsafeSetDefault($default_variable$);\n"
@ -742,7 +700,7 @@ void StringOneofFieldGenerator::GenerateInlineAccessorDefinitions(
"inline void $classname$::set_$name$(const char* value) {\n"
"$annotate_accessor$"
" $null_check$"
" if (!has_$name$()) {\n"
" if (!_internal_has_$name$()) {\n"
" clear_$oneof_name$();\n"
" set_has_$name$();\n"
" $field_member$.UnsafeSetDefault($default_variable$);\n"
@ -755,7 +713,7 @@ void StringOneofFieldGenerator::GenerateInlineAccessorDefinitions(
format(
"inline void $classname$::set_$name$(::StringPiece value) {\n"
"$annotate_accessor$"
" if (!has_$name$()) {\n"
" if (!_internal_has_$name$()) {\n"
" clear_$oneof_name$();\n"
" set_has_$name$();\n"
" $field_member$.UnsafeSetDefault($default_variable$);\n"
@ -770,7 +728,7 @@ void StringOneofFieldGenerator::GenerateInlineAccessorDefinitions(
"void $classname$::set_$name$(const $pointer_type$* value,\n"
" size_t size) {\n"
"$annotate_accessor$"
" if (!has_$name$()) {\n"
" if (!_internal_has_$name$()) {\n"
" clear_$oneof_name$();\n"
" set_has_$name$();\n"
" $field_member$.UnsafeSetDefault($default_variable$);\n"
@ -782,7 +740,7 @@ void StringOneofFieldGenerator::GenerateInlineAccessorDefinitions(
" // @@protoc_insertion_point(field_set_pointer:$full_name$)\n"
"}\n"
"inline std::string* $classname$::_internal_mutable_$name$() {\n"
" if (!$internal$has_$name$()) {\n"
" if (!_internal_has_$name$()) {\n"
" clear_$oneof_name$();\n"
" set_has_$name$();\n"
" $field_member$.UnsafeSetDefault($default_variable$);\n"
@ -793,7 +751,7 @@ void StringOneofFieldGenerator::GenerateInlineAccessorDefinitions(
"inline std::string* $classname$::$release_name$() {\n"
"$annotate_accessor$"
" // @@protoc_insertion_point(field_release:$full_name$)\n"
" if (has_$name$()) {\n"
" if (_internal_has_$name$()) {\n"
" clear_has_$oneof_name$();\n"
" return $field_member$.Release($default_variable$,\n"
" GetArenaNoVirtual());\n"
@ -819,7 +777,7 @@ void StringOneofFieldGenerator::GenerateInlineAccessorDefinitions(
" // "
"@@protoc_insertion_point(field_unsafe_arena_release:$full_name$)\n"
" $DCHK$(GetArenaNoVirtual() != nullptr);\n"
" if (has_$name$()) {\n"
" if (_internal_has_$name$()) {\n"
" clear_has_$oneof_name$();\n"
" return $field_member$.UnsafeArenaRelease(\n"
" $default_variable$, GetArenaNoVirtual());\n"
@ -831,7 +789,7 @@ void StringOneofFieldGenerator::GenerateInlineAccessorDefinitions(
"std::string* $name$) {\n"
"$annotate_accessor$"
" $DCHK$(GetArenaNoVirtual() != nullptr);\n"
" if (!has_$name$()) {\n"
" if (!_internal_has_$name$()) {\n"
" $field_member$.UnsafeSetDefault($default_variable$);\n"
" }\n"
" clear_$oneof_name$();\n"
@ -848,14 +806,14 @@ void StringOneofFieldGenerator::GenerateInlineAccessorDefinitions(
// No-arena case.
format(
"inline const std::string& $classname$::_internal_$name$() const {\n"
" if ($internal$has_$name$()) {\n"
" if (_internal_has_$name$()) {\n"
" return $field_member$.GetNoArena();\n"
" }\n"
" return *$default_variable$;\n"
"}\n"
"inline void $classname$::_internal_set_$name$(const std::string& "
"value) {\n"
" if (!$internal$has_$name$()) {\n"
" if (!_internal_has_$name$()) {\n"
" clear_$oneof_name$();\n"
" set_has_$name$();\n"
" $field_member$.UnsafeSetDefault($default_variable$);\n"
@ -865,7 +823,7 @@ void StringOneofFieldGenerator::GenerateInlineAccessorDefinitions(
"inline void $classname$::set_$name$(std::string&& value) {\n"
"$annotate_accessor$"
" // @@protoc_insertion_point(field_set:$full_name$)\n"
" if (!has_$name$()) {\n"
" if (!_internal_has_$name$()) {\n"
" clear_$oneof_name$();\n"
" set_has_$name$();\n"
" $field_member$.UnsafeSetDefault($default_variable$);\n"
@ -876,7 +834,7 @@ void StringOneofFieldGenerator::GenerateInlineAccessorDefinitions(
"inline void $classname$::set_$name$(const char* value) {\n"
"$annotate_accessor$"
" $null_check$"
" if (!has_$name$()) {\n"
" if (!_internal_has_$name$()) {\n"
" clear_$oneof_name$();\n"
" set_has_$name$();\n"
" $field_member$.UnsafeSetDefault($default_variable$);\n"
@ -889,7 +847,7 @@ void StringOneofFieldGenerator::GenerateInlineAccessorDefinitions(
format(
"inline void $classname$::set_$name$(::StringPiece value) {\n"
"$annotate_accessor$"
" if (!has_$name$()) {\n"
" if (!_internal_has_$name$()) {\n"
" clear_$oneof_name$();\n"
" set_has_$name$();\n"
" $field_member$.UnsafeSetDefault($default_variable$);\n"
@ -903,7 +861,7 @@ void StringOneofFieldGenerator::GenerateInlineAccessorDefinitions(
"void $classname$::set_$name$(const $pointer_type$* value, size_t "
"size) {\n"
"$annotate_accessor$"
" if (!has_$name$()) {\n"
" if (!_internal_has_$name$()) {\n"
" clear_$oneof_name$();\n"
" set_has_$name$();\n"
" $field_member$.UnsafeSetDefault($default_variable$);\n"
@ -913,7 +871,7 @@ void StringOneofFieldGenerator::GenerateInlineAccessorDefinitions(
" // @@protoc_insertion_point(field_set_pointer:$full_name$)\n"
"}\n"
"inline std::string* $classname$::_internal_mutable_$name$() {\n"
" if (!$internal$has_$name$()) {\n"
" if (!_internal_has_$name$()) {\n"
" clear_$oneof_name$();\n"
" set_has_$name$();\n"
" $field_member$.UnsafeSetDefault($default_variable$);\n"
@ -923,7 +881,7 @@ void StringOneofFieldGenerator::GenerateInlineAccessorDefinitions(
"inline std::string* $classname$::$release_name$() {\n"
"$annotate_accessor$"
" // @@protoc_insertion_point(field_release:$full_name$)\n"
" if (has_$name$()) {\n"
" if (_internal_has_$name$()) {\n"
" clear_has_$oneof_name$();\n"
" return $field_member$.ReleaseNoArena($default_variable$);\n"
" } else {\n"
@ -978,49 +936,11 @@ void StringOneofFieldGenerator::GenerateDestructorCode(
io::Printer* printer) const {
Formatter format(printer, variables_);
format(
"if (has_$name$()) {\n"
"if (_internal_has_$name$()) {\n"
" $field_member$.DestroyNoArena($default_variable$);\n"
"}\n");
}
void StringOneofFieldGenerator::GenerateMergeFromCodedStream(
io::Printer* printer) const {
Formatter format(printer, variables_);
// See above: ArenaString is not included in the open-source release.
if (!options_.opensource_runtime && SupportsArenas(descriptor_) && !lite_) {
// If has_$name$(), then the current string is either an ArenaString (no
// destructor necessary) or a materialized std::string (and is on the
// Arena's destructor list). No call to ArenaStringPtr::Destroy is needed.
format(
"if (arena != nullptr) {\n"
" clear_$oneof_name$();\n"
" if (!has_$name$()) {\n"
" $field_member$.UnsafeSetDefault($default_variable$);\n"
" set_has_$name$();\n"
" }\n"
" ::$proto_ns$::internal::TaggedPtr<std::string> new_value =\n"
" ::$proto_ns$::internal::ReadArenaString(input, arena);\n"
" DO_(!new_value.IsNull());\n"
" $field_member$.UnsafeSetTaggedPointer(new_value);\n"
"} else {\n"
" DO_(::$proto_ns$::internal::WireFormatLite::Read$declared_type$(\n"
" input, this->_internal_mutable_$name$()));\n"
"}\n");
} else {
format(
"DO_(::$proto_ns$::internal::WireFormatLite::Read$declared_type$(\n"
" input, this->_internal_mutable_$name$()));\n");
}
if (descriptor_->type() == FieldDescriptor::TYPE_STRING) {
GenerateUtf8CheckCodeForString(
descriptor_, options_, true,
"this->_internal_$name$().data(), "
"static_cast<int>(this->_internal_$name$().length()),\n",
format);
}
}
// ===================================================================
RepeatedStringFieldGenerator::RepeatedStringFieldGenerator(
@ -1092,6 +1012,7 @@ void RepeatedStringFieldGenerator::GenerateAccessorDeclarations(
"${1$mutable_$name$$}$()"
";\n"
"private:\n"
"const std::string& ${1$_internal_$name$$}$(int index) const;\n"
"std::string* _internal_add_$name$();\n"
"public:\n",
descriptor_);
@ -1114,21 +1035,24 @@ void RepeatedStringFieldGenerator::GenerateInlineAccessorDefinitions(
"}\n");
if (options_.safe_boundary_check) {
format(
"inline const std::string& $classname$::$name$(int index) const {\n"
"$annotate_accessor$"
" // @@protoc_insertion_point(field_get:$full_name$)\n"
"inline const std::string& $classname$::_internal_$name$(int index) "
"const {\n"
" return $name$_.InternalCheckedGet(\n"
" index, ::$proto_ns$::internal::GetEmptyStringAlreadyInited());\n"
"}\n");
} else {
format(
"inline const std::string& $classname$::$name$(int index) const {\n"
"$annotate_accessor$"
" // @@protoc_insertion_point(field_get:$full_name$)\n"
"inline const std::string& $classname$::_internal_$name$(int index) "
"const {\n"
" return $name$_.Get(index);\n"
"}\n");
}
format(
"inline const std::string& $classname$::$name$(int index) const {\n"
"$annotate_accessor$"
" // @@protoc_insertion_point(field_get:$full_name$)\n"
" return _internal_$name$(index);\n"
"}\n"
"inline std::string* $classname$::mutable_$name$(int index) {\n"
"$annotate_accessor$"
" // @@protoc_insertion_point(field_mutable:$full_name$)\n"
@ -1247,28 +1171,12 @@ void RepeatedStringFieldGenerator::GenerateCopyConstructorCode(
format("$name$_.CopyFrom(from.$name$_);");
}
void RepeatedStringFieldGenerator::GenerateMergeFromCodedStream(
io::Printer* printer) const {
Formatter format(printer, variables_);
format(
"DO_(::$proto_ns$::internal::WireFormatLite::Read$declared_type$(\n"
" input, this->_internal_add_$name$()));\n");
if (descriptor_->type() == FieldDescriptor::TYPE_STRING) {
GenerateUtf8CheckCodeForString(
descriptor_, options_, true,
"$name$_.Get($name$_.size() - 1).data(),\n"
"static_cast<int>($name$_.Get($name$_.size() - 1).length()),\n",
format);
}
}
void RepeatedStringFieldGenerator::GenerateSerializeWithCachedSizesToArray(
io::Printer* printer) const {
Formatter format(printer, variables_);
format(
"for (auto it = $field_member$.pointer_begin(),\n"
" end = $field_member$.pointer_end(); it < end; ++it) {\n"
" const auto& s = **it;\n");
"for (int i = 0, n = this->_internal_$name$_size(); i < n; i++) {\n"
" const auto& s = this->_internal_$name$(i);\n");
// format("for (const std::string& s : this->$name$()) {\n");
format.Indent();
if (descriptor_->type() == FieldDescriptor::TYPE_STRING) {

3
src/google/protobuf/compiler/cpp/cpp_string_field.h
View File

@ -65,7 +65,6 @@ class StringFieldGenerator : public FieldGenerator {
void GenerateDestructorCode(io::Printer* printer) const;
bool GenerateArenaDestructorCode(io::Printer* printer) const;
void GenerateDefaultInstanceAllocator(io::Printer* printer) const;
void GenerateMergeFromCodedStream(io::Printer* printer) const;
void GenerateSerializeWithCachedSizesToArray(io::Printer* printer) const;
void GenerateByteSize(io::Printer* printer) const;
uint32 CalculateFieldTag() const;
@ -97,7 +96,6 @@ class StringOneofFieldGenerator : public StringFieldGenerator {
void GenerateSwappingCode(io::Printer* printer) const;
void GenerateConstructorCode(io::Printer* printer) const;
void GenerateDestructorCode(io::Printer* printer) const;
void GenerateMergeFromCodedStream(io::Printer* printer) const;
private:
GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(StringOneofFieldGenerator);
@ -118,7 +116,6 @@ class RepeatedStringFieldGenerator : public FieldGenerator {
void GenerateSwappingCode(io::Printer* printer) const;
void GenerateConstructorCode(io::Printer* printer) const;
void GenerateCopyConstructorCode(io::Printer* printer) const;
void GenerateMergeFromCodedStream(io::Printer* printer) const;
void GenerateSerializeWithCachedSizesToArray(io::Printer* printer) const;
void GenerateByteSize(io::Printer* printer) const;

3
src/google/protobuf/compiler/cpp/cpp_unittest.inc
View File

@ -72,12 +72,13 @@
#include <google/protobuf/stubs/callback.h>
#include <google/protobuf/stubs/common.h>
#include <google/protobuf/stubs/logging.h>
#include <google/protobuf/stubs/substitute.h>
#include <google/protobuf/testing/googletest.h>
#include <gtest/gtest.h>
#include <google/protobuf/stubs/casts.h>
#include <google/protobuf/stubs/substitute.h>
#include <google/protobuf/stubs/stl_util.h>
// Must be included last.
#include <google/protobuf/port_def.inc>
namespace google {

2
src/google/protobuf/compiler/importer_unittest.cc
View File

@ -44,9 +44,9 @@
#include <google/protobuf/testing/file.h>
#include <google/protobuf/io/zero_copy_stream_impl.h>
#include <google/protobuf/descriptor.h>
#include <google/protobuf/stubs/substitute.h>
#include <google/protobuf/testing/googletest.h>
#include <gtest/gtest.h>
#include <google/protobuf/stubs/substitute.h>
#include <google/protobuf/stubs/map_util.h>
#include <google/protobuf/stubs/strutil.h>

3
src/google/protobuf/compiler/java/java_file.cc
View File

@ -237,7 +237,8 @@ bool FileGenerator::Validate(std::string* error) {
}
// Print a warning if optimize_for = LITE_RUNTIME is used.
if (file_->options().optimize_for() == FileOptions::LITE_RUNTIME) {
if (file_->options().optimize_for() == FileOptions::LITE_RUNTIME &&
!options_.enforce_lite) {
GOOGLE_LOG(WARNING)
<< "The optimize_for = LITE_RUNTIME option is no longer supported by "
<< "protobuf Java code generator and is ignored--protoc will always "

3
src/google/protobuf/compiler/java/java_helpers.cc
View File

@ -32,13 +32,14 @@
// Based on original Protocol Buffers design by
// Sanjay Ghemawat, Jeff Dean, and others.
#include <google/protobuf/compiler/java/java_helpers.h>
#include <algorithm>
#include <limits>
#include <unordered_set>
#include <vector>
#include <google/protobuf/stubs/stringprintf.h>
#include <google/protobuf/compiler/java/java_helpers.h>
#include <google/protobuf/compiler/java/java_name_resolver.h>
#include <google/protobuf/descriptor.pb.h>
#include <google/protobuf/wire_format.h>

2
src/google/protobuf/compiler/java/java_helpers.h
View File

@ -369,7 +369,7 @@ inline bool SupportUnknownEnumValue(const FileDescriptor* descriptor) {
return descriptor->syntax() == FileDescriptor::SYNTAX_PROTO3;
}
// Check whether a mesasge has repeated fields.
// Check whether a message has repeated fields.
bool HasRepeatedFields(const Descriptor* descriptor);
inline bool IsMapEntry(const Descriptor* descriptor) {

10
src/google/protobuf/compiler/java/java_message.cc
View File

@ -415,9 +415,13 @@ void ImmutableMessageGenerator::Generate(io::Printer* printer) {
"private int $oneof_name$Case_ = 0;\n"
"private java.lang.Object $oneof_name$_;\n");
// OneofCase enum
printer->Print(vars,
"public enum $oneof_capitalized_name$Case\n"
" implements com.google.protobuf.Internal.EnumLite {\n");
printer->Print(
vars,
"public enum $oneof_capitalized_name$Case\n"
// TODO(dweis): Remove EnumLite when we want to break compatibility with
// 3.x users
" implements com.google.protobuf.Internal.EnumLite,\n"
" com.google.protobuf.AbstractMessage.InternalOneOfEnum {\n");
printer->Indent();
for (int j = 0; j < descriptor_->oneof_decl(i)->field_count(); j++) {
const FieldDescriptor* field = descriptor_->oneof_decl(i)->field(j);

7
src/google/protobuf/compiler/java/java_message_lite.cc
View File

@ -235,9 +235,7 @@ void ImmutableMessageLiteGenerator::Generate(io::Printer* printer) {
"private int $oneof_name$Case_ = 0;\n"
"private java.lang.Object $oneof_name$_;\n");
// OneofCase enum
printer->Print(vars,
"public enum $oneof_capitalized_name$Case\n"
" implements com.google.protobuf.Internal.EnumLite {\n");
printer->Print(vars, "public enum $oneof_capitalized_name$Case {\n");
printer->Indent();
for (int j = 0; j < oneof->field_count(); j++) {
const FieldDescriptor* field = oneof->field(j);
@ -275,7 +273,8 @@ void ImmutableMessageLiteGenerator::Generate(io::Printer* printer) {
" default: return null;\n"
" }\n"
"}\n"
"@java.lang.Override\n"
// TODO(b/135620659): Rename this to "getFieldNumber" or something to
// disambiguate it from actual proto enums.
"public int getNumber() {\n"
" return this.value;\n"
"}\n",

3
src/google/protobuf/compiler/java/java_string_field.cc
View File

@ -838,7 +838,8 @@ void RepeatedImmutableStringFieldGenerator::GenerateBuilderMembers(
" return $name$_.get(index);\n"
"}\n");
printer->Annotate("{", "}", descriptor_);
WriteFieldStringBytesAccessorDocComment(printer, descriptor_, LIST_ADDER);
WriteFieldStringBytesAccessorDocComment(printer, descriptor_,
LIST_INDEXED_GETTER);
printer->Print(variables_,
"$deprecation$public com.google.protobuf.ByteString\n"
" ${$get$capitalized_name$Bytes$}$(int index) {\n"

7
src/google/protobuf/compiler/js/js_generator.cc
View File

@ -3142,6 +3142,13 @@ void Generator::GenerateClassDeserializeBinaryField(
printer->Print(", null");
}
printer->Print(", $defaultKey$", "defaultKey", JSFieldDefault(key_field));
if (value_field->type() == FieldDescriptor::TYPE_MESSAGE) {
printer->Print(", new $messageType$()", "messageType",
GetMessagePath(options, value_field->message_type()));
} else {
printer->Print(", $defaultValue$", "defaultValue",
JSFieldDefault(value_field));
}
printer->Print(");\n");
printer->Print(" });\n");
} else {

5
src/google/protobuf/compiler/mock_code_generator.cc
View File

@ -33,11 +33,12 @@
#include <google/protobuf/compiler/mock_code_generator.h>
#include <stdlib.h>
#include <iostream>
#include <memory>
#include <vector>
#include <google/protobuf/stubs/strutil.h>
#include <google/protobuf/stubs/strutil.h>
#include <google/protobuf/stubs/logging.h>
#include <google/protobuf/stubs/common.h>
@ -50,8 +51,8 @@
#include <google/protobuf/descriptor.pb.h>
#include <google/protobuf/descriptor.h>
#include <google/protobuf/text_format.h>
#include <google/protobuf/stubs/substitute.h>
#include <gtest/gtest.h>
#include <google/protobuf/stubs/substitute.h>
#ifdef major
#undef major

3
src/google/protobuf/compiler/parser.cc
View File

@ -2206,7 +2206,8 @@ bool Parser::ParseMethodOptions(const LocationRecorder& parent_location,
bool Parser::ParseLabel(FieldDescriptorProto::Label* label,
const LocationRecorder& field_location,
const FileDescriptorProto* containing_file) {
if (!LookingAt("optional") && !LookingAt("repeated") && !LookingAt("required")) {
if (!LookingAt("optional") && !LookingAt("repeated") &&
!LookingAt("required")) {
return false;
}
LocationRecorder location(field_location,

9
src/google/protobuf/compiler/parser_unittest.cc
View File

@ -32,13 +32,13 @@
// Based on original Protocol Buffers design by
// Sanjay Ghemawat, Jeff Dean, and others.
#include <google/protobuf/compiler/parser.h>
#include <algorithm>
#include <map>
#include <memory>
#include <vector>
#include <google/protobuf/compiler/parser.h>
#include <google/protobuf/test_util2.h>
#include <google/protobuf/unittest.pb.h>
#include <google/protobuf/unittest_custom_options.pb.h>
@ -47,11 +47,10 @@
#include <google/protobuf/descriptor.pb.h>
#include <google/protobuf/text_format.h>
#include <google/protobuf/wire_format.h>
#include <google/protobuf/stubs/substitute.h>
#include <google/protobuf/stubs/map_util.h>
#include <google/protobuf/testing/googletest.h>
#include <gtest/gtest.h>
#include <google/protobuf/stubs/substitute.h>
#include <google/protobuf/stubs/map_util.h>
namespace google {
namespace protobuf {

351
src/google/protobuf/compiler/plugin.pb.cc
View File

@ -289,7 +289,6 @@ void Version::Clear() {
_internal_metadata_.Clear();
}
#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* Version::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
_Internal::HasBits has_bits{};
@ -349,91 +348,6 @@ failure:
goto success;
#undef CHK_
}
#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool Version::MergePartialFromCodedStream(
::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
::PROTOBUF_NAMESPACE_ID::uint32 tag;
// @@protoc_insertion_point(parse_start:google.protobuf.compiler.Version)
for (;;) {
::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
tag = p.first;
if (!p.second) goto handle_unusual;
switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
// optional int32 major = 1;
case 1: {
if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) {
_Internal::set_has_major(&_has_bits_);
DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
::PROTOBUF_NAMESPACE_ID::int32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT32>(
input, &major_)));
} else {
goto handle_unusual;
}
break;
}
// optional int32 minor = 2;
case 2: {
if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) {
_Internal::set_has_minor(&_has_bits_);
DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
::PROTOBUF_NAMESPACE_ID::int32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT32>(
input, &minor_)));
} else {
goto handle_unusual;
}
break;
}
// optional int32 patch = 3;
case 3: {
if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (24 & 0xFF)) {
_Internal::set_has_patch(&_has_bits_);
DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
::PROTOBUF_NAMESPACE_ID::int32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT32>(
input, &patch_)));
} else {
goto handle_unusual;
}
break;
}
// optional string suffix = 4;
case 4: {
if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (34 & 0xFF)) {
DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString(
input, this->_internal_mutable_suffix()));
::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
this->_internal_suffix().data(), static_cast<int>(this->_internal_suffix().length()),
::PROTOBUF_NAMESPACE_ID::internal::WireFormat::PARSE,
"google.protobuf.compiler.Version.suffix");
} else {
goto handle_unusual;
}
break;
}
default: {
handle_unusual:
if (tag == 0) {
goto success;
}
DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
input, tag, _internal_metadata_.mutable_unknown_fields()));
break;
}
}
}
success:
// @@protoc_insertion_point(parse_success:google.protobuf.compiler.Version)
return true;
failure:
// @@protoc_insertion_point(parse_failure:google.protobuf.compiler.Version)
return false;
#undef DO_
}
#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
::PROTOBUF_NAMESPACE_ID::uint8* Version::InternalSerializeWithCachedSizesToArray(
::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
@ -445,19 +359,19 @@ failure:
// optional int32 major = 1;
if (cached_has_bits & 0x00000002u) {
stream->EnsureSpace(&target);
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->major(), target);
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_major(), target);
}
// optional int32 minor = 2;
if (cached_has_bits & 0x00000004u) {
stream->EnsureSpace(&target);
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->minor(), target);
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_minor(), target);
}
// optional int32 patch = 3;
if (cached_has_bits & 0x00000008u) {
stream->EnsureSpace(&target);
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(3, this->patch(), target);
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(3, this->_internal_patch(), target);
}
// optional string suffix = 4;
@ -499,21 +413,21 @@ size_t Version::ByteSizeLong() const {
if (cached_has_bits & 0x00000002u) {
total_size += 1 +
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
this->major());
this->_internal_major());
}
// optional int32 minor = 2;
if (cached_has_bits & 0x00000004u) {
total_size += 1 +
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
this->minor());
this->_internal_minor());
}
// optional int32 patch = 3;
if (cached_has_bits & 0x00000008u) {
total_size += 1 +
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
this->patch());
this->_internal_patch());
}
}
@ -642,7 +556,7 @@ CodeGeneratorRequest::CodeGeneratorRequest(const CodeGeneratorRequest& from)
if (from._internal_has_parameter()) {
parameter_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.parameter_);
}
if (from.has_compiler_version()) {
if (from._internal_has_compiler_version()) {
compiler_version_ = new PROTOBUF_NAMESPACE_ID::compiler::Version(*from.compiler_version_);
} else {
compiler_version_ = nullptr;
@ -697,7 +611,6 @@ void CodeGeneratorRequest::Clear() {
_internal_metadata_.Clear();
}
#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* CodeGeneratorRequest::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
_Internal::HasBits has_bits{};
@ -728,7 +641,7 @@ const char* CodeGeneratorRequest::_InternalParse(const char* ptr, ::PROTOBUF_NAM
// optional .google.protobuf.compiler.Version compiler_version = 3;
case 3:
if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
ptr = ctx->ParseMessage(mutable_compiler_version(), ptr);
ptr = ctx->ParseMessage(_internal_mutable_compiler_version(), ptr);
CHK_(ptr);
} else goto handle_unusual;
continue;
@ -738,7 +651,7 @@ const char* CodeGeneratorRequest::_InternalParse(const char* ptr, ::PROTOBUF_NAM
ptr -= 1;
do {
ptr += 1;
ptr = ctx->ParseMessage(add_proto_file(), ptr);
ptr = ctx->ParseMessage(_internal_add_proto_file(), ptr);
CHK_(ptr);
if (!ctx->DataAvailable(ptr)) break;
} while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<122>(ptr));
@ -764,90 +677,6 @@ failure:
goto success;
#undef CHK_
}
#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool CodeGeneratorRequest::MergePartialFromCodedStream(
::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
::PROTOBUF_NAMESPACE_ID::uint32 tag;
// @@protoc_insertion_point(parse_start:google.protobuf.compiler.CodeGeneratorRequest)
for (;;) {
::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
tag = p.first;
if (!p.second) goto handle_unusual;
switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
// repeated string file_to_generate = 1;
case 1: {
if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) {
DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString(
input, this->_internal_add_file_to_generate()));
::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
file_to_generate_.Get(file_to_generate_.size() - 1).data(),
static_cast<int>(file_to_generate_.Get(file_to_generate_.size() - 1).length()),
::PROTOBUF_NAMESPACE_ID::internal::WireFormat::PARSE,
"google.protobuf.compiler.CodeGeneratorRequest.file_to_generate");
} else {
goto handle_unusual;
}
break;
}
// optional string parameter = 2;
case 2: {
if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) {
DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString(
input, this->_internal_mutable_parameter()));
::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
this->_internal_parameter().data(), static_cast<int>(this->_internal_parameter().length()),
::PROTOBUF_NAMESPACE_ID::internal::WireFormat::PARSE,
"google.protobuf.compiler.CodeGeneratorRequest.parameter");
} else {
goto handle_unusual;
}
break;
}
// optional .google.protobuf.compiler.Version compiler_version = 3;
case 3: {
if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (26 & 0xFF)) {
DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
input, mutable_compiler_version()));
} else {
goto handle_unusual;
}
break;
}
// repeated .google.protobuf.FileDescriptorProto proto_file = 15;
case 15: {
if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (122 & 0xFF)) {
DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
input, add_proto_file()));
} else {
goto handle_unusual;
}
break;
}
default: {
handle_unusual:
if (tag == 0) {
goto success;
}
DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
input, tag, _internal_metadata_.mutable_unknown_fields()));
break;
}
}
}
success:
// @@protoc_insertion_point(parse_success:google.protobuf.compiler.CodeGeneratorRequest)
return true;
failure:
// @@protoc_insertion_point(parse_failure:google.protobuf.compiler.CodeGeneratorRequest)
return false;
#undef DO_
}
#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
::PROTOBUF_NAMESPACE_ID::uint8* CodeGeneratorRequest::InternalSerializeWithCachedSizesToArray(
::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
@ -856,9 +685,8 @@ failure:
(void) cached_has_bits;
// repeated string file_to_generate = 1;
for (auto it = file_to_generate_.pointer_begin(),
end = file_to_generate_.pointer_end(); it < end; ++it) {
const auto& s = **it;
for (int i = 0, n = this->_internal_file_to_generate_size(); i < n; i++) {
const auto& s = this->_internal_file_to_generate(i);
::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
s.data(), static_cast<int>(s.length()),
::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
@ -886,11 +714,11 @@ failure:
}
// repeated .google.protobuf.FileDescriptorProto proto_file = 15;
for (auto it = this->proto_file_.pointer_begin(),
end = this->proto_file_.pointer_end(); it < end; ++it) {
for (unsigned int i = 0,
n = static_cast<unsigned int>(this->_internal_proto_file_size()); i < n; i++) {
stream->EnsureSpace(&target);
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
InternalWriteMessageToArray(15, **it, target, stream);
InternalWriteMessageToArray(15, this->_internal_proto_file(i), target, stream);
}
if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
@ -918,7 +746,7 @@ size_t CodeGeneratorRequest::ByteSizeLong() const {
}
// repeated .google.protobuf.FileDescriptorProto proto_file = 15;
total_size += 1UL * this->proto_file_size();
total_size += 1UL * this->_internal_proto_file_size();
for (const auto& msg : this->proto_file_) {
total_size +=
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
@ -981,7 +809,7 @@ void CodeGeneratorRequest::MergeFrom(const CodeGeneratorRequest& from) {
parameter_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.parameter_);
}
if (cached_has_bits & 0x00000002u) {
mutable_compiler_version()->PROTOBUF_NAMESPACE_ID::compiler::Version::MergeFrom(from.compiler_version());
_internal_mutable_compiler_version()->PROTOBUF_NAMESPACE_ID::compiler::Version::MergeFrom(from._internal_compiler_version());
}
}
}
@ -1113,7 +941,6 @@ void CodeGeneratorResponse_File::Clear() {
_internal_metadata_.Clear();
}
#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* CodeGeneratorResponse_File::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
_Internal::HasBits has_bits{};
@ -1163,82 +990,6 @@ failure:
goto success;
#undef CHK_
}
#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool CodeGeneratorResponse_File::MergePartialFromCodedStream(
::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
::PROTOBUF_NAMESPACE_ID::uint32 tag;
// @@protoc_insertion_point(parse_start:google.protobuf.compiler.CodeGeneratorResponse.File)
for (;;) {
::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
tag = p.first;
if (!p.second) goto handle_unusual;
switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
// optional string name = 1;
case 1: {
if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) {
DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString(
input, this->_internal_mutable_name()));
::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
this->_internal_name().data(), static_cast<int>(this->_internal_name().length()),
::PROTOBUF_NAMESPACE_ID::internal::WireFormat::PARSE,
"google.protobuf.compiler.CodeGeneratorResponse.File.name");
} else {
goto handle_unusual;
}
break;
}
// optional string insertion_point = 2;
case 2: {
if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) {
DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString(
input, this->_internal_mutable_insertion_point()));
::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
this->_internal_insertion_point().data(), static_cast<int>(this->_internal_insertion_point().length()),
::PROTOBUF_NAMESPACE_ID::internal::WireFormat::PARSE,
"google.protobuf.compiler.CodeGeneratorResponse.File.insertion_point");
} else {
goto handle_unusual;
}
break;
}
// optional string content = 15;
case 15: {
if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (122 & 0xFF)) {
DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString(
input, this->_internal_mutable_content()));
::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
this->_internal_content().data(), static_cast<int>(this->_internal_content().length()),
::PROTOBUF_NAMESPACE_ID::internal::WireFormat::PARSE,
"google.protobuf.compiler.CodeGeneratorResponse.File.content");
} else {
goto handle_unusual;
}
break;
}
default: {
handle_unusual:
if (tag == 0) {
goto success;
}
DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
input, tag, _internal_metadata_.mutable_unknown_fields()));
break;
}
}
}
success:
// @@protoc_insertion_point(parse_success:google.protobuf.compiler.CodeGeneratorResponse.File)
return true;
failure:
// @@protoc_insertion_point(parse_failure:google.protobuf.compiler.CodeGeneratorResponse.File)
return false;
#undef DO_
}
#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
::PROTOBUF_NAMESPACE_ID::uint8* CodeGeneratorResponse_File::InternalSerializeWithCachedSizesToArray(
::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
@ -1468,7 +1219,6 @@ void CodeGeneratorResponse::Clear() {
_internal_metadata_.Clear();
}
#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* CodeGeneratorResponse::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
_Internal::HasBits has_bits{};
@ -1490,7 +1240,7 @@ const char* CodeGeneratorResponse::_InternalParse(const char* ptr, ::PROTOBUF_NA
ptr -= 1;
do {
ptr += 1;
ptr = ctx->ParseMessage(add_file(), ptr);
ptr = ctx->ParseMessage(_internal_add_file(), ptr);
CHK_(ptr);
if (!ctx->DataAvailable(ptr)) break;
} while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<122>(ptr));
@ -1516,63 +1266,6 @@ failure:
goto success;
#undef CHK_
}
#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool CodeGeneratorResponse::MergePartialFromCodedStream(
::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
::PROTOBUF_NAMESPACE_ID::uint32 tag;
// @@protoc_insertion_point(parse_start:google.protobuf.compiler.CodeGeneratorResponse)
for (;;) {
::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
tag = p.first;
if (!p.second) goto handle_unusual;
switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
// optional string error = 1;
case 1: {
if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) {
DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString(
input, this->_internal_mutable_error()));
::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
this->_internal_error().data(), static_cast<int>(this->_internal_error().length()),
::PROTOBUF_NAMESPACE_ID::internal::WireFormat::PARSE,
"google.protobuf.compiler.CodeGeneratorResponse.error");
} else {
goto handle_unusual;
}
break;
}
// repeated .google.protobuf.compiler.CodeGeneratorResponse.File file = 15;
case 15: {
if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (122 & 0xFF)) {
DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
input, add_file()));
} else {
goto handle_unusual;
}
break;
}
default: {
handle_unusual:
if (tag == 0) {
goto success;
}
DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
input, tag, _internal_metadata_.mutable_unknown_fields()));
break;
}
}
}
success:
// @@protoc_insertion_point(parse_success:google.protobuf.compiler.CodeGeneratorResponse)
return true;
failure:
// @@protoc_insertion_point(parse_failure:google.protobuf.compiler.CodeGeneratorResponse)
return false;
#undef DO_
}
#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
::PROTOBUF_NAMESPACE_ID::uint8* CodeGeneratorResponse::InternalSerializeWithCachedSizesToArray(
::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
@ -1592,11 +1285,11 @@ failure:
}
// repeated .google.protobuf.compiler.CodeGeneratorResponse.File file = 15;
for (auto it = this->file_.pointer_begin(),
end = this->file_.pointer_end(); it < end; ++it) {
for (unsigned int i = 0,
n = static_cast<unsigned int>(this->_internal_file_size()); i < n; i++) {
stream->EnsureSpace(&target);
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
InternalWriteMessageToArray(15, **it, target, stream);
InternalWriteMessageToArray(15, this->_internal_file(i), target, stream);
}
if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
@ -1616,7 +1309,7 @@ size_t CodeGeneratorResponse::ByteSizeLong() const {
(void) cached_has_bits;
// repeated .google.protobuf.compiler.CodeGeneratorResponse.File file = 15;
total_size += 1UL * this->file_size();
total_size += 1UL * this->_internal_file_size();
for (const auto& msg : this->file_) {
total_size +=
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
@ -1662,7 +1355,7 @@ void CodeGeneratorResponse::MergeFrom(const CodeGeneratorResponse& from) {
(void) cached_has_bits;
file_.MergeFrom(from.file_);
if (from.has_error()) {
if (from._internal_has_error()) {
_has_bits_[0] |= 0x00000001u;
error_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.error_);
}

175
src/google/protobuf/compiler/plugin.pb.h
View File

@ -164,12 +164,7 @@ class PROTOC_EXPORT Version :
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
#else
bool MergePartialFromCodedStream(
::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
@ -239,6 +234,10 @@ class PROTOC_EXPORT Version :
void clear_major();
::PROTOBUF_NAMESPACE_ID::int32 major() const;
void set_major(::PROTOBUF_NAMESPACE_ID::int32 value);
private:
::PROTOBUF_NAMESPACE_ID::int32 _internal_major() const;
void _internal_set_major(::PROTOBUF_NAMESPACE_ID::int32 value);
public:
// optional int32 minor = 2;
bool has_minor() const;
@ -248,6 +247,10 @@ class PROTOC_EXPORT Version :
void clear_minor();
::PROTOBUF_NAMESPACE_ID::int32 minor() const;
void set_minor(::PROTOBUF_NAMESPACE_ID::int32 value);
private:
::PROTOBUF_NAMESPACE_ID::int32 _internal_minor() const;
void _internal_set_minor(::PROTOBUF_NAMESPACE_ID::int32 value);
public:
// optional int32 patch = 3;
bool has_patch() const;
@ -257,6 +260,10 @@ class PROTOC_EXPORT Version :
void clear_patch();
::PROTOBUF_NAMESPACE_ID::int32 patch() const;
void set_patch(::PROTOBUF_NAMESPACE_ID::int32 value);
private:
::PROTOBUF_NAMESPACE_ID::int32 _internal_patch() const;
void _internal_set_patch(::PROTOBUF_NAMESPACE_ID::int32 value);
public:
// @@protoc_insertion_point(class_scope:google.protobuf.compiler.Version)
private:
@ -349,12 +356,7 @@ class PROTOC_EXPORT CodeGeneratorRequest :
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
#else
bool MergePartialFromCodedStream(
::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
@ -398,6 +400,9 @@ class PROTOC_EXPORT CodeGeneratorRequest :
};
// repeated string file_to_generate = 1;
int file_to_generate_size() const;
private:
int _internal_file_to_generate_size() const;
public:
void clear_file_to_generate();
const std::string& file_to_generate(int index) const;
std::string* mutable_file_to_generate(int index);
@ -413,15 +418,23 @@ class PROTOC_EXPORT CodeGeneratorRequest :
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& file_to_generate() const;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_file_to_generate();
private:
const std::string& _internal_file_to_generate(int index) const;
std::string* _internal_add_file_to_generate();
public:
// repeated .google.protobuf.FileDescriptorProto proto_file = 15;
int proto_file_size() const;
private:
int _internal_proto_file_size() const;
public:
void clear_proto_file();
PROTOBUF_NAMESPACE_ID::FileDescriptorProto* mutable_proto_file(int index);
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::FileDescriptorProto >*
mutable_proto_file();
private:
const PROTOBUF_NAMESPACE_ID::FileDescriptorProto& _internal_proto_file(int index) const;
PROTOBUF_NAMESPACE_ID::FileDescriptorProto* _internal_add_proto_file();
public:
const PROTOBUF_NAMESPACE_ID::FileDescriptorProto& proto_file(int index) const;
PROTOBUF_NAMESPACE_ID::FileDescriptorProto* add_proto_file();
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::FileDescriptorProto >&
@ -457,6 +470,10 @@ class PROTOC_EXPORT CodeGeneratorRequest :
PROTOBUF_NAMESPACE_ID::compiler::Version* release_compiler_version();
PROTOBUF_NAMESPACE_ID::compiler::Version* mutable_compiler_version();
void set_allocated_compiler_version(PROTOBUF_NAMESPACE_ID::compiler::Version* compiler_version);
private:
const PROTOBUF_NAMESPACE_ID::compiler::Version& _internal_compiler_version() const;
PROTOBUF_NAMESPACE_ID::compiler::Version* _internal_mutable_compiler_version();
public:
// @@protoc_insertion_point(class_scope:google.protobuf.compiler.CodeGeneratorRequest)
private:
@ -549,12 +566,7 @@ class PROTOC_EXPORT CodeGeneratorResponse_File :
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
#else
bool MergePartialFromCodedStream(
::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
@ -745,12 +757,7 @@ class PROTOC_EXPORT CodeGeneratorResponse :
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
#else
bool MergePartialFromCodedStream(
::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
@ -794,10 +801,17 @@ class PROTOC_EXPORT CodeGeneratorResponse :
};
// repeated .google.protobuf.compiler.CodeGeneratorResponse.File file = 15;
int file_size() const;
private:
int _internal_file_size() const;
public:
void clear_file();
PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse_File* mutable_file(int index);
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse_File >*
mutable_file();
private:
const PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse_File& _internal_file(int index) const;
PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse_File* _internal_add_file();
public:
const PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse_File& file(int index) const;
PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse_File* add_file();
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse_File >&
@ -847,7 +861,8 @@ class PROTOC_EXPORT CodeGeneratorResponse :
// optional int32 major = 1;
inline bool Version::_internal_has_major() const {
return (_has_bits_[0] & 0x00000002u) != 0;
bool value = (_has_bits_[0] & 0x00000002u) != 0;
return value;
}
inline bool Version::has_major() const {
return _internal_has_major();
@ -856,19 +871,26 @@ inline void Version::clear_major() {
major_ = 0;
_has_bits_[0] &= ~0x00000002u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Version::major() const {
// @@protoc_insertion_point(field_get:google.protobuf.compiler.Version.major)
inline ::PROTOBUF_NAMESPACE_ID::int32 Version::_internal_major() const {
return major_;
}
inline void Version::set_major(::PROTOBUF_NAMESPACE_ID::int32 value) {
inline ::PROTOBUF_NAMESPACE_ID::int32 Version::major() const {
// @@protoc_insertion_point(field_get:google.protobuf.compiler.Version.major)
return _internal_major();
}
inline void Version::_internal_set_major(::PROTOBUF_NAMESPACE_ID::int32 value) {
_has_bits_[0] |= 0x00000002u;
major_ = value;
}
inline void Version::set_major(::PROTOBUF_NAMESPACE_ID::int32 value) {
_internal_set_major(value);
// @@protoc_insertion_point(field_set:google.protobuf.compiler.Version.major)
}
// optional int32 minor = 2;
inline bool Version::_internal_has_minor() const {
return (_has_bits_[0] & 0x00000004u) != 0;
bool value = (_has_bits_[0] & 0x00000004u) != 0;
return value;
}
inline bool Version::has_minor() const {
return _internal_has_minor();
@ -877,19 +899,26 @@ inline void Version::clear_minor() {
minor_ = 0;
_has_bits_[0] &= ~0x00000004u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Version::minor() const {
// @@protoc_insertion_point(field_get:google.protobuf.compiler.Version.minor)
inline ::PROTOBUF_NAMESPACE_ID::int32 Version::_internal_minor() const {
return minor_;
}
inline void Version::set_minor(::PROTOBUF_NAMESPACE_ID::int32 value) {
inline ::PROTOBUF_NAMESPACE_ID::int32 Version::minor() const {
// @@protoc_insertion_point(field_get:google.protobuf.compiler.Version.minor)
return _internal_minor();
}
inline void Version::_internal_set_minor(::PROTOBUF_NAMESPACE_ID::int32 value) {
_has_bits_[0] |= 0x00000004u;
minor_ = value;
}
inline void Version::set_minor(::PROTOBUF_NAMESPACE_ID::int32 value) {
_internal_set_minor(value);
// @@protoc_insertion_point(field_set:google.protobuf.compiler.Version.minor)
}
// optional int32 patch = 3;
inline bool Version::_internal_has_patch() const {
return (_has_bits_[0] & 0x00000008u) != 0;
bool value = (_has_bits_[0] & 0x00000008u) != 0;
return value;
}
inline bool Version::has_patch() const {
return _internal_has_patch();
@ -898,19 +927,26 @@ inline void Version::clear_patch() {
patch_ = 0;
_has_bits_[0] &= ~0x00000008u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Version::patch() const {
// @@protoc_insertion_point(field_get:google.protobuf.compiler.Version.patch)
inline ::PROTOBUF_NAMESPACE_ID::int32 Version::_internal_patch() const {
return patch_;
}
inline void Version::set_patch(::PROTOBUF_NAMESPACE_ID::int32 value) {
inline ::PROTOBUF_NAMESPACE_ID::int32 Version::patch() const {
// @@protoc_insertion_point(field_get:google.protobuf.compiler.Version.patch)
return _internal_patch();
}
inline void Version::_internal_set_patch(::PROTOBUF_NAMESPACE_ID::int32 value) {
_has_bits_[0] |= 0x00000008u;
patch_ = value;
}
inline void Version::set_patch(::PROTOBUF_NAMESPACE_ID::int32 value) {
_internal_set_patch(value);
// @@protoc_insertion_point(field_set:google.protobuf.compiler.Version.patch)
}
// optional string suffix = 4;
inline bool Version::_internal_has_suffix() const {
return (_has_bits_[0] & 0x00000001u) != 0;
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool Version::has_suffix() const {
return _internal_has_suffix();
@ -983,9 +1019,12 @@ inline void Version::set_allocated_suffix(std::string* suffix) {
// CodeGeneratorRequest
// repeated string file_to_generate = 1;
inline int CodeGeneratorRequest::file_to_generate_size() const {
inline int CodeGeneratorRequest::_internal_file_to_generate_size() const {
return file_to_generate_.size();
}
inline int CodeGeneratorRequest::file_to_generate_size() const {
return _internal_file_to_generate_size();
}
inline void CodeGeneratorRequest::clear_file_to_generate() {
file_to_generate_.Clear();
}
@ -993,9 +1032,12 @@ inline std::string* CodeGeneratorRequest::add_file_to_generate() {
// @@protoc_insertion_point(field_add_mutable:google.protobuf.compiler.CodeGeneratorRequest.file_to_generate)
return _internal_add_file_to_generate();
}
inline const std::string& CodeGeneratorRequest::_internal_file_to_generate(int index) const {
return file_to_generate_.Get(index);
}
inline const std::string& CodeGeneratorRequest::file_to_generate(int index) const {
// @@protoc_insertion_point(field_get:google.protobuf.compiler.CodeGeneratorRequest.file_to_generate)
return file_to_generate_.Get(index);
return _internal_file_to_generate(index);
}
inline std::string* CodeGeneratorRequest::mutable_file_to_generate(int index) {
// @@protoc_insertion_point(field_mutable:google.protobuf.compiler.CodeGeneratorRequest.file_to_generate)
@ -1052,7 +1094,8 @@ CodeGeneratorRequest::mutable_file_to_generate() {
// optional string parameter = 2;
inline bool CodeGeneratorRequest::_internal_has_parameter() const {
return (_has_bits_[0] & 0x00000001u) != 0;
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool CodeGeneratorRequest::has_parameter() const {
return _internal_has_parameter();
@ -1121,9 +1164,12 @@ inline void CodeGeneratorRequest::set_allocated_parameter(std::string* parameter
}
// repeated .google.protobuf.FileDescriptorProto proto_file = 15;
inline int CodeGeneratorRequest::proto_file_size() const {
inline int CodeGeneratorRequest::_internal_proto_file_size() const {
return proto_file_.size();
}
inline int CodeGeneratorRequest::proto_file_size() const {
return _internal_proto_file_size();
}
inline PROTOBUF_NAMESPACE_ID::FileDescriptorProto* CodeGeneratorRequest::mutable_proto_file(int index) {
// @@protoc_insertion_point(field_mutable:google.protobuf.compiler.CodeGeneratorRequest.proto_file)
return proto_file_.Mutable(index);
@ -1133,13 +1179,19 @@ CodeGeneratorRequest::mutable_proto_file() {
// @@protoc_insertion_point(field_mutable_list:google.protobuf.compiler.CodeGeneratorRequest.proto_file)
return &proto_file_;
}
inline const PROTOBUF_NAMESPACE_ID::FileDescriptorProto& CodeGeneratorRequest::_internal_proto_file(int index) const {
return proto_file_.Get(index);
}
inline const PROTOBUF_NAMESPACE_ID::FileDescriptorProto& CodeGeneratorRequest::proto_file(int index) const {
// @@protoc_insertion_point(field_get:google.protobuf.compiler.CodeGeneratorRequest.proto_file)
return proto_file_.Get(index);
return _internal_proto_file(index);
}
inline PROTOBUF_NAMESPACE_ID::FileDescriptorProto* CodeGeneratorRequest::_internal_add_proto_file() {
return proto_file_.Add();
}
inline PROTOBUF_NAMESPACE_ID::FileDescriptorProto* CodeGeneratorRequest::add_proto_file() {
// @@protoc_insertion_point(field_add:google.protobuf.compiler.CodeGeneratorRequest.proto_file)
return proto_file_.Add();
return _internal_add_proto_file();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::FileDescriptorProto >&
CodeGeneratorRequest::proto_file() const {
@ -1149,7 +1201,9 @@ CodeGeneratorRequest::proto_file() const {
// optional .google.protobuf.compiler.Version compiler_version = 3;
inline bool CodeGeneratorRequest::_internal_has_compiler_version() const {
return (_has_bits_[0] & 0x00000002u) != 0;
bool value = (_has_bits_[0] & 0x00000002u) != 0;
PROTOBUF_ASSUME(!value || compiler_version_ != nullptr);
return value;
}
inline bool CodeGeneratorRequest::has_compiler_version() const {
return _internal_has_compiler_version();
@ -1158,12 +1212,15 @@ inline void CodeGeneratorRequest::clear_compiler_version() {
if (compiler_version_ != nullptr) compiler_version_->Clear();
_has_bits_[0] &= ~0x00000002u;
}
inline const PROTOBUF_NAMESPACE_ID::compiler::Version& CodeGeneratorRequest::compiler_version() const {
inline const PROTOBUF_NAMESPACE_ID::compiler::Version& CodeGeneratorRequest::_internal_compiler_version() const {
const PROTOBUF_NAMESPACE_ID::compiler::Version* p = compiler_version_;
// @@protoc_insertion_point(field_get:google.protobuf.compiler.CodeGeneratorRequest.compiler_version)
return p != nullptr ? *p : *reinterpret_cast<const PROTOBUF_NAMESPACE_ID::compiler::Version*>(
&PROTOBUF_NAMESPACE_ID::compiler::_Version_default_instance_);
}
inline const PROTOBUF_NAMESPACE_ID::compiler::Version& CodeGeneratorRequest::compiler_version() const {
// @@protoc_insertion_point(field_get:google.protobuf.compiler.CodeGeneratorRequest.compiler_version)
return _internal_compiler_version();
}
inline PROTOBUF_NAMESPACE_ID::compiler::Version* CodeGeneratorRequest::release_compiler_version() {
// @@protoc_insertion_point(field_release:google.protobuf.compiler.CodeGeneratorRequest.compiler_version)
_has_bits_[0] &= ~0x00000002u;
@ -1171,15 +1228,18 @@ inline PROTOBUF_NAMESPACE_ID::compiler::Version* CodeGeneratorRequest::release_c
compiler_version_ = nullptr;
return temp;
}
inline PROTOBUF_NAMESPACE_ID::compiler::Version* CodeGeneratorRequest::mutable_compiler_version() {
inline PROTOBUF_NAMESPACE_ID::compiler::Version* CodeGeneratorRequest::_internal_mutable_compiler_version() {
_has_bits_[0] |= 0x00000002u;
if (compiler_version_ == nullptr) {
auto* p = CreateMaybeMessage<PROTOBUF_NAMESPACE_ID::compiler::Version>(GetArenaNoVirtual());
compiler_version_ = p;
}
// @@protoc_insertion_point(field_mutable:google.protobuf.compiler.CodeGeneratorRequest.compiler_version)
return compiler_version_;
}
inline PROTOBUF_NAMESPACE_ID::compiler::Version* CodeGeneratorRequest::mutable_compiler_version() {
// @@protoc_insertion_point(field_mutable:google.protobuf.compiler.CodeGeneratorRequest.compiler_version)
return _internal_mutable_compiler_version();
}
inline void CodeGeneratorRequest::set_allocated_compiler_version(PROTOBUF_NAMESPACE_ID::compiler::Version* compiler_version) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == nullptr) {
@ -1205,7 +1265,8 @@ inline void CodeGeneratorRequest::set_allocated_compiler_version(PROTOBUF_NAMESP
// optional string name = 1;
inline bool CodeGeneratorResponse_File::_internal_has_name() const {
return (_has_bits_[0] & 0x00000001u) != 0;
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool CodeGeneratorResponse_File::has_name() const {
return _internal_has_name();
@ -1275,7 +1336,8 @@ inline void CodeGeneratorResponse_File::set_allocated_name(std::string* name) {
// optional string insertion_point = 2;
inline bool CodeGeneratorResponse_File::_internal_has_insertion_point() const {
return (_has_bits_[0] & 0x00000002u) != 0;
bool value = (_has_bits_[0] & 0x00000002u) != 0;
return value;
}
inline bool CodeGeneratorResponse_File::has_insertion_point() const {
return _internal_has_insertion_point();
@ -1345,7 +1407,8 @@ inline void CodeGeneratorResponse_File::set_allocated_insertion_point(std::strin
// optional string content = 15;
inline bool CodeGeneratorResponse_File::_internal_has_content() const {
return (_has_bits_[0] & 0x00000004u) != 0;
bool value = (_has_bits_[0] & 0x00000004u) != 0;
return value;
}
inline bool CodeGeneratorResponse_File::has_content() const {
return _internal_has_content();
@ -1419,7 +1482,8 @@ inline void CodeGeneratorResponse_File::set_allocated_content(std::string* conte
// optional string error = 1;
inline bool CodeGeneratorResponse::_internal_has_error() const {
return (_has_bits_[0] & 0x00000001u) != 0;
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool CodeGeneratorResponse::has_error() const {
return _internal_has_error();
@ -1488,9 +1552,12 @@ inline void CodeGeneratorResponse::set_allocated_error(std::string* error) {
}
// repeated .google.protobuf.compiler.CodeGeneratorResponse.File file = 15;
inline int CodeGeneratorResponse::file_size() const {
inline int CodeGeneratorResponse::_internal_file_size() const {
return file_.size();
}
inline int CodeGeneratorResponse::file_size() const {
return _internal_file_size();
}
inline void CodeGeneratorResponse::clear_file() {
file_.Clear();
}
@ -1503,13 +1570,19 @@ CodeGeneratorResponse::mutable_file() {
// @@protoc_insertion_point(field_mutable_list:google.protobuf.compiler.CodeGeneratorResponse.file)
return &file_;
}
inline const PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse_File& CodeGeneratorResponse::_internal_file(int index) const {
return file_.Get(index);
}
inline const PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse_File& CodeGeneratorResponse::file(int index) const {
// @@protoc_insertion_point(field_get:google.protobuf.compiler.CodeGeneratorResponse.file)
return file_.Get(index);
return _internal_file(index);
}
inline PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse_File* CodeGeneratorResponse::_internal_add_file() {
return file_.Add();
}
inline PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse_File* CodeGeneratorResponse::add_file() {
// @@protoc_insertion_point(field_add:google.protobuf.compiler.CodeGeneratorResponse.file)
return file_.Add();
return _internal_add_file();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse_File >&
CodeGeneratorResponse::file() const {

6
src/google/protobuf/compiler/python/python_generator.cc
View File

@ -44,6 +44,8 @@
// performance-minded Python code leverage the fast C++ implementation
// directly.
#include <google/protobuf/compiler/python/python_generator.h>
#include <algorithm>
#include <limits>
#include <map>
@ -52,12 +54,10 @@
#include <utility>
#include <vector>
#include <google/protobuf/compiler/python/python_generator.h>
#include <google/protobuf/descriptor.pb.h>
#include <google/protobuf/stubs/logging.h>
#include <google/protobuf/stubs/common.h>
#include <google/protobuf/stubs/stringprintf.h>
#include <google/protobuf/descriptor.pb.h>
#include <google/protobuf/io/printer.h>
#include <google/protobuf/io/zero_copy_stream.h>
#include <google/protobuf/descriptor.h>

48
src/google/protobuf/descriptor.cc
View File

@ -59,8 +59,8 @@
#include <google/protobuf/text_format.h>
#include <google/protobuf/unknown_field_set.h>
#include <google/protobuf/wire_format.h>
#include <google/protobuf/stubs/substitute.h>
#include <google/protobuf/stubs/casts.h>
#include <google/protobuf/stubs/substitute.h>
#include <google/protobuf/io/strtod.h>
#include <google/protobuf/stubs/map_util.h>
#include <google/protobuf/stubs/stl_util.h>
@ -905,6 +905,14 @@ inline Symbol FileDescriptorTables::FindNestedSymbolOfType(
Symbol DescriptorPool::Tables::FindByNameHelper(const DescriptorPool* pool,
const std::string& name) {
if (pool->mutex_ != nullptr) {
// Fast path: the Symbol is already cached. This is just a hash lookup.
ReaderMutexLock lock(pool->mutex_);
if (known_bad_symbols_.empty() && known_bad_files_.empty()) {
Symbol result = FindSymbol(name);
if (!result.IsNull()) return result;
}
}
MutexLockMaybe lock(pool->mutex_);
if (pool->fallback_database_ != nullptr) {
known_bad_symbols_.clear();
@ -3681,7 +3689,14 @@ Symbol DescriptorBuilder::FindSymbolNotEnforcingDepsHelper(
Symbol DescriptorBuilder::FindSymbolNotEnforcingDeps(const std::string& name,
bool build_it) {
return FindSymbolNotEnforcingDepsHelper(pool_, name, build_it);
Symbol result = FindSymbolNotEnforcingDepsHelper(pool_, name, build_it);
// Only find symbols which were defined in this file or one of its
// dependencies.
const FileDescriptor* file = result.GetFile();
if (file == file_ || dependencies_.count(file) > 0) {
unused_dependency_.erase(file);
}
return result;
}
Symbol DescriptorBuilder::FindSymbol(const std::string& name, bool build_it) {
@ -3698,7 +3713,6 @@ Symbol DescriptorBuilder::FindSymbol(const std::string& name, bool build_it) {
// dependencies.
const FileDescriptor* file = result.GetFile();
if (file == file_ || dependencies_.count(file) > 0) {
unused_dependency_.erase(file);
return result;
}
@ -7104,35 +7118,13 @@ void DescriptorBuilder::LogUnusedDependency(const FileDescriptorProto& proto,
const FileDescriptor* result) {
if (!unused_dependency_.empty()) {
std::set<std::string> annotation_extensions;
annotation_extensions.insert("google.protobuf.MessageOptions");
annotation_extensions.insert("google.protobuf.FileOptions");
annotation_extensions.insert("google.protobuf.FieldOptions");
annotation_extensions.insert("google.protobuf.EnumOptions");
annotation_extensions.insert("google.protobuf.EnumValueOptions");
annotation_extensions.insert("google.protobuf.EnumValueOptions");
annotation_extensions.insert("google.protobuf.ServiceOptions");
annotation_extensions.insert("google.protobuf.MethodOptions");
annotation_extensions.insert("google.protobuf.StreamOptions");
for (std::set<const FileDescriptor*>::const_iterator it =
unused_dependency_.begin();
it != unused_dependency_.end(); ++it) {
// Do not log warnings for proto files which extend annotations.
int i;
for (i = 0; i < (*it)->extension_count(); ++i) {
if (annotation_extensions.find(
(*it)->extension(i)->containing_type()->full_name()) !=
annotation_extensions.end()) {
break;
}
}
// Log warnings for unused imported files.
if (i == (*it)->extension_count()) {
std::string error_message =
"Import " + (*it)->name() + " but not used.";
AddWarning((*it)->name(), proto, DescriptorPool::ErrorCollector::IMPORT,
error_message);
}
std::string error_message = "Import " + (*it)->name() + " but not used.";
AddWarning((*it)->name(), proto, DescriptorPool::ErrorCollector::IMPORT,
error_message);
}
}
}

3117
src/google/protobuf/descriptor.pb.cc
View File

File diff suppressed because it is too large Load Diff

2149
src/google/protobuf/descriptor.pb.h
View File

File diff suppressed because it is too large Load Diff

18
src/google/protobuf/descriptor_unittest.cc
View File

@ -42,6 +42,10 @@
#include <google/protobuf/compiler/parser.h>
#include <google/protobuf/unittest.pb.h>
#include <google/protobuf/unittest_custom_options.pb.h>
#include <google/protobuf/stubs/common.h>
#include <google/protobuf/stubs/logging.h>
#include <google/protobuf/stubs/logging.h>
#include <google/protobuf/stubs/stringprintf.h>
#include <google/protobuf/unittest_lazy_dependencies.pb.h>
#include <google/protobuf/unittest_proto3_arena.pb.h>
#include <google/protobuf/io/tokenizer.h>
@ -51,15 +55,10 @@
#include <google/protobuf/descriptor_database.h>
#include <google/protobuf/dynamic_message.h>
#include <google/protobuf/text_format.h>
#include <google/protobuf/stubs/substitute.h>
#include <google/protobuf/stubs/common.h>
#include <google/protobuf/stubs/logging.h>
#include <google/protobuf/stubs/logging.h>
#include <google/protobuf/stubs/stringprintf.h>
#include <google/protobuf/stubs/strutil.h>
#include <google/protobuf/testing/googletest.h>
#include <gtest/gtest.h>
#include <google/protobuf/stubs/substitute.h>
#include <google/protobuf/port_def.inc>
@ -3477,7 +3476,12 @@ TEST(CustomOptions, UnusedImportWarning) {
MockErrorCollector error_collector;
EXPECT_TRUE(pool.BuildFileCollectingErrors(file_proto, &error_collector));
EXPECT_EQ("", error_collector.warning_text_);
EXPECT_EQ(
"custom_options_import.proto: "
"google/protobuf/unittest_custom_options.proto: IMPORT: Import "
"google/protobuf/unittest_custom_options.proto but not used.\n",
error_collector.warning_text_);
EXPECT_EQ("", error_collector.text_);
}
// Verifies that proto files can correctly be parsed, even if the

70
src/google/protobuf/duration.pb.cc
View File

@ -153,7 +153,6 @@ void Duration::Clear() {
_internal_metadata_.Clear();
}
#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* Duration::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaNoVirtual(); (void)arena;
@ -195,63 +194,6 @@ failure:
goto success;
#undef CHK_
}
#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool Duration::MergePartialFromCodedStream(
::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
::PROTOBUF_NAMESPACE_ID::uint32 tag;
// @@protoc_insertion_point(parse_start:google.protobuf.Duration)
for (;;) {
::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
tag = p.first;
if (!p.second) goto handle_unusual;
switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
// int64 seconds = 1;
case 1: {
if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) {
DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>(
input, &seconds_)));
} else {
goto handle_unusual;
}
break;
}
// int32 nanos = 2;
case 2: {
if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) {
DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
::PROTOBUF_NAMESPACE_ID::int32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT32>(
input, &nanos_)));
} else {
goto handle_unusual;
}
break;
}
default: {
handle_unusual:
if (tag == 0) {
goto success;
}
DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
input, tag, _internal_metadata_.mutable_unknown_fields()));
break;
}
}
}
success:
// @@protoc_insertion_point(parse_success:google.protobuf.Duration)
return true;
failure:
// @@protoc_insertion_point(parse_failure:google.protobuf.Duration)
return false;
#undef DO_
}
#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
::PROTOBUF_NAMESPACE_ID::uint8* Duration::InternalSerializeWithCachedSizesToArray(
::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
@ -262,13 +204,13 @@ failure:
// int64 seconds = 1;
if (this->seconds() != 0) {
stream->EnsureSpace(&target);
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(1, this->seconds(), target);
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(1, this->_internal_seconds(), target);
}
// int32 nanos = 2;
if (this->nanos() != 0) {
stream->EnsureSpace(&target);
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->nanos(), target);
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_nanos(), target);
}
if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
@ -291,14 +233,14 @@ size_t Duration::ByteSizeLong() const {
if (this->seconds() != 0) {
total_size += 1 +
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size(
this->seconds());
this->_internal_seconds());
}
// int32 nanos = 2;
if (this->nanos() != 0) {
total_size += 1 +
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
this->nanos());
this->_internal_nanos());
}
if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
@ -333,10 +275,10 @@ void Duration::MergeFrom(const Duration& from) {
(void) cached_has_bits;
if (from.seconds() != 0) {
set_seconds(from.seconds());
_internal_set_seconds(from._internal_seconds());
}
if (from.nanos() != 0) {
set_nanos(from.nanos());
_internal_set_nanos(from._internal_nanos());
}
}

37
src/google/protobuf/duration.pb.h
View File

@ -150,12 +150,7 @@ class PROTOBUF_EXPORT Duration :
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
#else
bool MergePartialFromCodedStream(
::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
@ -204,11 +199,19 @@ class PROTOBUF_EXPORT Duration :
void clear_seconds();
::PROTOBUF_NAMESPACE_ID::int64 seconds() const;
void set_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
private:
::PROTOBUF_NAMESPACE_ID::int64 _internal_seconds() const;
void _internal_set_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
public:
// int32 nanos = 2;
void clear_nanos();
::PROTOBUF_NAMESPACE_ID::int32 nanos() const;
void set_nanos(::PROTOBUF_NAMESPACE_ID::int32 value);
private:
::PROTOBUF_NAMESPACE_ID::int32 _internal_nanos() const;
void _internal_set_nanos(::PROTOBUF_NAMESPACE_ID::int32 value);
public:
// @@protoc_insertion_point(class_scope:google.protobuf.Duration)
private:
@ -238,13 +241,19 @@ class PROTOBUF_EXPORT Duration :
inline void Duration::clear_seconds() {
seconds_ = PROTOBUF_LONGLONG(0);
}
inline ::PROTOBUF_NAMESPACE_ID::int64 Duration::seconds() const {
// @@protoc_insertion_point(field_get:google.protobuf.Duration.seconds)
inline ::PROTOBUF_NAMESPACE_ID::int64 Duration::_internal_seconds() const {
return seconds_;
}
inline void Duration::set_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
inline ::PROTOBUF_NAMESPACE_ID::int64 Duration::seconds() const {
// @@protoc_insertion_point(field_get:google.protobuf.Duration.seconds)
return _internal_seconds();
}
inline void Duration::_internal_set_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
seconds_ = value;
}
inline void Duration::set_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
_internal_set_seconds(value);
// @@protoc_insertion_point(field_set:google.protobuf.Duration.seconds)
}
@ -252,13 +261,19 @@ inline void Duration::set_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
inline void Duration::clear_nanos() {
nanos_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Duration::nanos() const {
// @@protoc_insertion_point(field_get:google.protobuf.Duration.nanos)
inline ::PROTOBUF_NAMESPACE_ID::int32 Duration::_internal_nanos() const {
return nanos_;
}
inline void Duration::set_nanos(::PROTOBUF_NAMESPACE_ID::int32 value) {
inline ::PROTOBUF_NAMESPACE_ID::int32 Duration::nanos() const {
// @@protoc_insertion_point(field_get:google.protobuf.Duration.nanos)
return _internal_nanos();
}
inline void Duration::_internal_set_nanos(::PROTOBUF_NAMESPACE_ID::int32 value) {
nanos_ = value;
}
inline void Duration::set_nanos(::PROTOBUF_NAMESPACE_ID::int32 value) {
_internal_set_nanos(value);
// @@protoc_insertion_point(field_set:google.protobuf.Duration.nanos)
}

27
src/google/protobuf/empty.pb.cc
View File

@ -141,7 +141,6 @@ void Empty::Clear() {
_internal_metadata_.Clear();
}
#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* Empty::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaNoVirtual(); (void)arena;
@ -168,32 +167,6 @@ failure:
goto success;
#undef CHK_
}
#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool Empty::MergePartialFromCodedStream(
::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
::PROTOBUF_NAMESPACE_ID::uint32 tag;
// @@protoc_insertion_point(parse_start:google.protobuf.Empty)
for (;;) {
::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
tag = p.first;
if (!p.second) goto handle_unusual;
handle_unusual:
if (tag == 0) {
goto success;
}
DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
input, tag, _internal_metadata_.mutable_unknown_fields()));
}
success:
// @@protoc_insertion_point(parse_success:google.protobuf.Empty)
return true;
failure:
// @@protoc_insertion_point(parse_failure:google.protobuf.Empty)
return false;
#undef DO_
}
#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
::PROTOBUF_NAMESPACE_ID::uint8* Empty::InternalSerializeWithCachedSizesToArray(
::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {

5
src/google/protobuf/empty.pb.h
View File

@ -150,12 +150,7 @@ class PROTOBUF_EXPORT Empty :
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
#else
bool MergePartialFromCodedStream(
::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }

3
src/google/protobuf/extension_set.cc
View File

@ -1196,7 +1196,6 @@ bool ExtensionSet::ParseField(uint32 tag, io::CodedInputStream* input,
}
}
#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* ExtensionSet::ParseField(
uint64 tag, const char* ptr, const MessageLite* containing_type,
internal::InternalMetadataWithArenaLite* metadata,
@ -1220,8 +1219,6 @@ const char* ExtensionSet::ParseMessageSetItem(
return ParseMessageSetItemTmpl(ptr, containing_type, metadata, ctx);
}
#endif
bool ExtensionSet::ParseFieldWithExtensionInfo(int number,
bool was_packed_on_wire,
const ExtensionInfo& extension,

11
src/google/protobuf/extension_set.h
View File

@ -146,7 +146,7 @@ class PROTOBUF_EXPORT GeneratedExtensionFinder : public ExtensionFinder {
public:
GeneratedExtensionFinder(const MessageLite* containing_type)
: containing_type_(containing_type) {}
virtual ~GeneratedExtensionFinder() {}
~GeneratedExtensionFinder() override {}
// Returns true and fills in *output if found, otherwise returns false.
bool Find(int number, ExtensionInfo* output) override;
@ -394,7 +394,6 @@ class PROTOBUF_EXPORT ExtensionSet {
const MessageLite* containing_type,
io::CodedOutputStream* unknown_fields);
#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
// Lite parser
const char* ParseField(uint64 tag, const char* ptr,
const MessageLite* containing_type,
@ -434,7 +433,6 @@ class PROTOBUF_EXPORT ExtensionSet {
}
return ptr;
}
#endif
// Parse an entire message in MessageSet format. Such messages have no
// fields, only extensions.
@ -541,9 +539,7 @@ class PROTOBUF_EXPORT ExtensionSet {
virtual bool ReadMessage(const MessageLite& prototype,
io::CodedInputStream* input) = 0;
#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
virtual const char* _InternalParse(const char* ptr, ParseContext* ctx) = 0;
#endif
virtual uint8* WriteMessageToArray(
int number, uint8* target, io::EpsCopyOutputStream* stream) const = 0;
@ -762,7 +758,6 @@ class PROTOBUF_EXPORT ExtensionSet {
ExtensionFinder* extension_finder,
MessageSetFieldSkipper* field_skipper);
#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool FindExtension(int wire_type, uint32 field,
const MessageLite* containing_type,
const internal::ParseContext* ctx,
@ -807,7 +802,6 @@ class PROTOBUF_EXPORT ExtensionSet {
const Msg* containing_type,
Metadata* metadata,
internal::ParseContext* ctx);
#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
// Hack: RepeatedPtrFieldBase declares ExtensionSet as a friend. This
// friendship should automatically extend to ExtensionSet::Extension, but
@ -1583,8 +1577,7 @@ template <typename ExtendeeType, typename TypeTraitsType,
void LinkExtensionReflection(
const google::protobuf::internal::ExtensionIdentifier<
ExtendeeType, TypeTraitsType, field_type, is_packed>& extension) {
const void* volatile unused = &extension;
(void)&unused; // Use address to avoid an extra load of volatile variable.
internal::StrongReference(extension);
}
} // namespace protobuf

3
src/google/protobuf/extension_set_heavy.cc
View File

@ -318,7 +318,6 @@ bool DescriptorPoolExtensionFinder::Find(int number, ExtensionInfo* output) {
}
#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool ExtensionSet::FindExtension(int wire_type, uint32 field,
const Message* containing_type,
const internal::ParseContext* ctx,
@ -370,8 +369,6 @@ const char* ExtensionSet::ParseMessageSetItem(
return ParseMessageSetItemTmpl(ptr, containing_type, metadata, ctx);
}
#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool ExtensionSet::ParseField(uint32 tag, io::CodedInputStream* input,
const Message* containing_type,
UnknownFieldSet* unknown_fields) {

2
src/google/protobuf/extension_set_inl.h
View File

@ -38,7 +38,6 @@ namespace google {
namespace protobuf {
namespace internal {
#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
template <typename T>
const char* ExtensionSet::ParseFieldWithExtensionInfo(
int number, bool was_packed_on_wire, const ExtensionInfo& extension,
@ -267,7 +266,6 @@ const char* ExtensionSet::ParseMessageSetItemTmpl(const char* ptr,
}
return ptr;
}
#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
} // namespace internal
} // namespace protobuf

53
src/google/protobuf/field_mask.pb.cc
View File

@ -147,7 +147,6 @@ void FieldMask::Clear() {
_internal_metadata_.Clear();
}
#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* FieldMask::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaNoVirtual(); (void)arena;
@ -187,53 +186,6 @@ failure:
goto success;
#undef CHK_
}
#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool FieldMask::MergePartialFromCodedStream(
::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
::PROTOBUF_NAMESPACE_ID::uint32 tag;
// @@protoc_insertion_point(parse_start:google.protobuf.FieldMask)
for (;;) {
::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
tag = p.first;
if (!p.second) goto handle_unusual;
switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
// repeated string paths = 1;
case 1: {
if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) {
DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString(
input, this->_internal_add_paths()));
DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
paths_.Get(paths_.size() - 1).data(),
static_cast<int>(paths_.Get(paths_.size() - 1).length()),
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE,
"google.protobuf.FieldMask.paths"));
} else {
goto handle_unusual;
}
break;
}
default: {
handle_unusual:
if (tag == 0) {
goto success;
}
DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
input, tag, _internal_metadata_.mutable_unknown_fields()));
break;
}
}
}
success:
// @@protoc_insertion_point(parse_success:google.protobuf.FieldMask)
return true;
failure:
// @@protoc_insertion_point(parse_failure:google.protobuf.FieldMask)
return false;
#undef DO_
}
#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
::PROTOBUF_NAMESPACE_ID::uint8* FieldMask::InternalSerializeWithCachedSizesToArray(
::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
@ -242,9 +194,8 @@ failure:
(void) cached_has_bits;
// repeated string paths = 1;
for (auto it = paths_.pointer_begin(),
end = paths_.pointer_end(); it < end; ++it) {
const auto& s = **it;
for (int i = 0, n = this->_internal_paths_size(); i < n; i++) {
const auto& s = this->_internal_paths(i);
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
s.data(), static_cast<int>(s.length()),
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,

19
src/google/protobuf/field_mask.pb.h
View File

@ -150,12 +150,7 @@ class PROTOBUF_EXPORT FieldMask :
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
#else
bool MergePartialFromCodedStream(
::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
@ -201,6 +196,9 @@ class PROTOBUF_EXPORT FieldMask :
};
// repeated string paths = 1;
int paths_size() const;
private:
int _internal_paths_size() const;
public:
void clear_paths();
const std::string& paths(int index) const;
std::string* mutable_paths(int index);
@ -216,6 +214,7 @@ class PROTOBUF_EXPORT FieldMask :
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& paths() const;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_paths();
private:
const std::string& _internal_paths(int index) const;
std::string* _internal_add_paths();
public:
@ -243,9 +242,12 @@ class PROTOBUF_EXPORT FieldMask :
// FieldMask
// repeated string paths = 1;
inline int FieldMask::paths_size() const {
inline int FieldMask::_internal_paths_size() const {
return paths_.size();
}
inline int FieldMask::paths_size() const {
return _internal_paths_size();
}
inline void FieldMask::clear_paths() {
paths_.Clear();
}
@ -253,9 +255,12 @@ inline std::string* FieldMask::add_paths() {
// @@protoc_insertion_point(field_add_mutable:google.protobuf.FieldMask.paths)
return _internal_add_paths();
}
inline const std::string& FieldMask::_internal_paths(int index) const {
return paths_.Get(index);
}
inline const std::string& FieldMask::paths(int index) const {
// @@protoc_insertion_point(field_get:google.protobuf.FieldMask.paths)
return paths_.Get(index);
return _internal_paths(index);
}
inline std::string* FieldMask::mutable_paths(int index) {
// @@protoc_insertion_point(field_mutable:google.protobuf.FieldMask.paths)

Some files were not shown because too many files have changed in this diff Show More