1031 lines
38 KiB
C++
1031 lines
38 KiB
C++
// Protocol Buffers - Google's data interchange format
|
|
// Copyright 2008 Google Inc. All rights reserved.
|
|
//
|
|
// Use of this source code is governed by a BSD-style
|
|
// license that can be found in the LICENSE file or at
|
|
// https://developers.google.com/open-source/licenses/bsd
|
|
|
|
// Author: dweis@google.com (Daniel Weis)
|
|
// Based on original Protocol Buffers design by
|
|
// Sanjay Ghemawat, Jeff Dean, and others.
|
|
|
|
#include "google/protobuf/compiler/java/lite/message.h"
|
|
|
|
#include <algorithm>
|
|
#include <cstddef>
|
|
#include <cstdint>
|
|
#include <memory>
|
|
#include <string>
|
|
#include <utility>
|
|
#include <vector>
|
|
|
|
#include "absl/container/flat_hash_map.h"
|
|
#include "absl/log/absl_check.h"
|
|
#include "absl/strings/ascii.h"
|
|
#include "absl/strings/str_cat.h"
|
|
#include "absl/strings/string_view.h"
|
|
#include "absl/strings/substitute.h"
|
|
#include "google/protobuf/compiler/java/context.h"
|
|
#include "google/protobuf/compiler/java/doc_comment.h"
|
|
#include "google/protobuf/compiler/java/field_common.h"
|
|
#include "google/protobuf/compiler/java/generator.h"
|
|
#include "google/protobuf/compiler/java/generator_factory.h"
|
|
#include "google/protobuf/compiler/java/helpers.h"
|
|
#include "google/protobuf/compiler/java/lite/enum.h"
|
|
#include "google/protobuf/compiler/java/lite/extension.h"
|
|
#include "google/protobuf/compiler/java/lite/make_field_generators.h"
|
|
#include "google/protobuf/compiler/java/lite/message_builder.h"
|
|
#include "google/protobuf/compiler/java/name_resolver.h"
|
|
#include "google/protobuf/descriptor.pb.h"
|
|
#include "google/protobuf/io/coded_stream.h"
|
|
#include "google/protobuf/io/printer.h"
|
|
#include "google/protobuf/wire_format.h"
|
|
|
|
// Must be last.
|
|
#include "google/protobuf/port_def.inc"
|
|
|
|
namespace google {
|
|
namespace protobuf {
|
|
namespace compiler {
|
|
namespace java {
|
|
|
|
using internal::WireFormat;
|
|
using internal::WireFormatLite;
|
|
|
|
// ===================================================================
|
|
ImmutableMessageLiteGenerator::ImmutableMessageLiteGenerator(
|
|
const Descriptor* descriptor, Context* context)
|
|
: MessageGenerator(descriptor),
|
|
context_(context),
|
|
name_resolver_(context->GetNameResolver()),
|
|
field_generators_(MakeImmutableFieldLiteGenerators(descriptor, context)) {
|
|
ABSL_CHECK(!HasDescriptorMethods(descriptor->file(), context->EnforceLite()))
|
|
<< "Generator factory error: A lite message generator is used to "
|
|
"generate non-lite messages.";
|
|
for (int i = 0; i < descriptor_->field_count(); i++) {
|
|
if (IsRealOneof(descriptor_->field(i))) {
|
|
const OneofDescriptor* oneof = descriptor_->field(i)->containing_oneof();
|
|
ABSL_CHECK(oneofs_.emplace(oneof->index(), oneof).first->second == oneof);
|
|
}
|
|
}
|
|
}
|
|
|
|
ImmutableMessageLiteGenerator::~ImmutableMessageLiteGenerator() {}
|
|
|
|
void ImmutableMessageLiteGenerator::GenerateStaticVariables(
|
|
io::Printer* printer, int* bytecode_estimate) {
|
|
// No-op for lite.
|
|
}
|
|
|
|
int ImmutableMessageLiteGenerator::GenerateStaticVariableInitializers(
|
|
io::Printer* printer) {
|
|
// No-op for lite.
|
|
return 0;
|
|
}
|
|
|
|
// ===================================================================
|
|
|
|
void ImmutableMessageLiteGenerator::GenerateInterface(io::Printer* printer) {
|
|
MaybePrintGeneratedAnnotation(context_, printer, descriptor_,
|
|
/* immutable = */ true, "OrBuilder");
|
|
|
|
absl::flat_hash_map<absl::string_view, std::string> variables = {
|
|
{"{", ""},
|
|
{"}", ""},
|
|
{"deprecation",
|
|
descriptor_->options().deprecated() ? "@java.lang.Deprecated " : ""},
|
|
{"extra_interfaces", ExtraMessageOrBuilderInterfaces(descriptor_)},
|
|
{"classname", descriptor_->name()},
|
|
};
|
|
|
|
if (!context_->options().opensource_runtime) {
|
|
printer->Print("@com.google.protobuf.Internal.ProtoNonnullApi\n");
|
|
}
|
|
if (descriptor_->extension_range_count() > 0) {
|
|
printer->Print(
|
|
variables,
|
|
"$deprecation$public interface ${$$classname$OrBuilder$}$ extends \n"
|
|
" $extra_interfaces$\n"
|
|
" com.google.protobuf.GeneratedMessageLite.\n"
|
|
" ExtendableMessageOrBuilder<\n"
|
|
" $classname$, $classname$.Builder> {\n");
|
|
} else {
|
|
printer->Print(
|
|
variables,
|
|
"$deprecation$public interface ${$$classname$OrBuilder$}$ extends\n"
|
|
" $extra_interfaces$\n"
|
|
" com.google.protobuf.MessageLiteOrBuilder {\n");
|
|
}
|
|
printer->Annotate("{", "}", descriptor_);
|
|
|
|
printer->Indent();
|
|
for (int i = 0; i < descriptor_->field_count(); i++) {
|
|
printer->Print("\n");
|
|
field_generators_.get(descriptor_->field(i))
|
|
.GenerateInterfaceMembers(printer);
|
|
}
|
|
for (auto& kv : oneofs_) {
|
|
const OneofDescriptor* oneof = kv.second;
|
|
variables["oneof_capitalized_name"] =
|
|
context_->GetOneofGeneratorInfo(oneof)->capitalized_name;
|
|
variables["classname"] =
|
|
context_->GetNameResolver()->GetImmutableClassName(descriptor_);
|
|
printer->Print(variables,
|
|
"\n"
|
|
"public ${$$classname$.$oneof_capitalized_name$Case$}$ "
|
|
"get$oneof_capitalized_name$Case();\n");
|
|
printer->Annotate("{", "}", oneof);
|
|
}
|
|
printer->Outdent();
|
|
|
|
printer->Print("}\n");
|
|
}
|
|
|
|
// ===================================================================
|
|
|
|
void ImmutableMessageLiteGenerator::Generate(io::Printer* printer) {
|
|
bool is_own_file = IsOwnFile(descriptor_, /* immutable = */ true);
|
|
|
|
absl::flat_hash_map<absl::string_view, std::string> variables = {{"{", ""},
|
|
{"}", ""}};
|
|
variables["static"] = is_own_file ? " " : " static ";
|
|
variables["classname"] = descriptor_->name();
|
|
variables["extra_interfaces"] = ExtraMessageInterfaces(descriptor_);
|
|
variables["deprecation"] =
|
|
descriptor_->options().deprecated() ? "@java.lang.Deprecated " : "";
|
|
|
|
WriteMessageDocComment(printer, descriptor_, context_->options());
|
|
MaybePrintGeneratedAnnotation(context_, printer, descriptor_,
|
|
/* immutable = */ true);
|
|
|
|
|
|
// The builder_type stores the super type name of the nested Builder class.
|
|
std::string builder_type;
|
|
if (descriptor_->extension_range_count() > 0) {
|
|
printer->Print(
|
|
variables,
|
|
"$deprecation$public $static$final class ${$$classname$$}$ extends\n"
|
|
" com.google.protobuf.GeneratedMessageLite.ExtendableMessage<\n"
|
|
" $classname$, $classname$.Builder> implements\n"
|
|
" $extra_interfaces$\n"
|
|
" $classname$OrBuilder {\n");
|
|
builder_type = absl::Substitute(
|
|
"com.google.protobuf.GeneratedMessageLite.ExtendableBuilder<$0, ?>",
|
|
name_resolver_->GetImmutableClassName(descriptor_));
|
|
} else {
|
|
printer->Print(
|
|
variables,
|
|
"$deprecation$public $static$final class ${$$classname$$}$ extends\n"
|
|
" com.google.protobuf.GeneratedMessageLite<\n"
|
|
" $classname$, $classname$.Builder> implements\n"
|
|
" $extra_interfaces$\n"
|
|
" $classname$OrBuilder {\n");
|
|
|
|
builder_type = "com.google.protobuf.GeneratedMessageLite.Builder";
|
|
}
|
|
printer->Annotate("{", "}", descriptor_);
|
|
printer->Indent();
|
|
|
|
GenerateConstructor(printer);
|
|
|
|
// Nested types
|
|
for (int i = 0; i < descriptor_->enum_type_count(); i++) {
|
|
EnumLiteGenerator(descriptor_->enum_type(i), true, context_)
|
|
.Generate(printer);
|
|
}
|
|
|
|
for (int i = 0; i < descriptor_->nested_type_count(); i++) {
|
|
// Don't generate Java classes for map entry messages.
|
|
if (IsMapEntry(descriptor_->nested_type(i))) continue;
|
|
ImmutableMessageLiteGenerator messageGenerator(descriptor_->nested_type(i),
|
|
context_);
|
|
messageGenerator.GenerateInterface(printer);
|
|
messageGenerator.Generate(printer);
|
|
}
|
|
|
|
// Integers for bit fields.
|
|
int totalBits = 0;
|
|
for (int i = 0; i < descriptor_->field_count(); i++) {
|
|
totalBits +=
|
|
field_generators_.get(descriptor_->field(i)).GetNumBitsForMessage();
|
|
}
|
|
int totalInts = (totalBits + 31) / 32;
|
|
for (int i = 0; i < totalInts; i++) {
|
|
printer->Print("private int $bit_field_name$;\n", "bit_field_name",
|
|
GetBitFieldName(i));
|
|
}
|
|
|
|
// oneof
|
|
absl::flat_hash_map<absl::string_view, std::string> vars = {{"{", ""},
|
|
{"}", ""}};
|
|
for (auto& kv : oneofs_) {
|
|
const OneofDescriptor* oneof = kv.second;
|
|
vars["oneof_name"] = context_->GetOneofGeneratorInfo(oneof)->name;
|
|
vars["oneof_capitalized_name"] =
|
|
context_->GetOneofGeneratorInfo(oneof)->capitalized_name;
|
|
vars["oneof_index"] = absl::StrCat((oneof)->index());
|
|
if (context_->options().opensource_runtime) {
|
|
// oneofCase_ and oneof_
|
|
printer->Print(vars,
|
|
"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");
|
|
printer->Annotate("{", "}", oneof);
|
|
printer->Indent();
|
|
for (int j = 0; j < (oneof)->field_count(); j++) {
|
|
const FieldDescriptor* field = (oneof)->field(j);
|
|
printer->Print("$field_name$($field_number$),\n", "field_name",
|
|
absl::AsciiStrToUpper(field->name()), "field_number",
|
|
absl::StrCat(field->number()));
|
|
printer->Annotate("field_name", field);
|
|
}
|
|
printer->Print("$cap_oneof_name$_NOT_SET(0);\n", "cap_oneof_name",
|
|
absl::AsciiStrToUpper(vars["oneof_name"]));
|
|
printer->Print(vars,
|
|
"private final int value;\n"
|
|
"private $oneof_capitalized_name$Case(int value) {\n"
|
|
" this.value = value;\n"
|
|
"}\n");
|
|
if (context_->options().opensource_runtime) {
|
|
printer->Print(
|
|
vars,
|
|
"/**\n"
|
|
" * @deprecated Use {@link #forNumber(int)} instead.\n"
|
|
" */\n"
|
|
"@java.lang.Deprecated\n"
|
|
"public static $oneof_capitalized_name$Case valueOf(int value) {\n"
|
|
" return forNumber(value);\n"
|
|
"}\n"
|
|
"\n");
|
|
}
|
|
printer->Print(
|
|
vars,
|
|
"public static $oneof_capitalized_name$Case forNumber(int value) {\n"
|
|
" switch (value) {\n");
|
|
for (int j = 0; j < (oneof)->field_count(); j++) {
|
|
const FieldDescriptor* field = (oneof)->field(j);
|
|
printer->Print(" case $field_number$: return $field_name$;\n",
|
|
"field_number", absl::StrCat(field->number()),
|
|
"field_name", absl::AsciiStrToUpper(field->name()));
|
|
}
|
|
printer->Print(
|
|
" case 0: return $cap_oneof_name$_NOT_SET;\n"
|
|
" default: return null;\n"
|
|
" }\n"
|
|
"}\n"
|
|
// TODO: Rename this to "getFieldNumber" or something to
|
|
// disambiguate it from actual proto enums.
|
|
"public int getNumber() {\n"
|
|
" return this.value;\n"
|
|
"}\n",
|
|
"cap_oneof_name", absl::AsciiStrToUpper(vars["oneof_name"]));
|
|
printer->Outdent();
|
|
printer->Print("};\n\n");
|
|
// oneofCase()
|
|
printer->Print(vars,
|
|
"@java.lang.Override\n"
|
|
"public $oneof_capitalized_name$Case\n"
|
|
"${$get$oneof_capitalized_name$Case$}$() {\n"
|
|
" return $oneof_capitalized_name$Case.forNumber(\n"
|
|
" $oneof_name$Case_);\n"
|
|
"}\n");
|
|
printer->Annotate("{", "}", oneof);
|
|
printer->Print(vars,
|
|
"\n"
|
|
"private void ${$clear$oneof_capitalized_name$$}$() {\n"
|
|
" $oneof_name$Case_ = 0;\n"
|
|
" $oneof_name$_ = null;\n"
|
|
"}\n"
|
|
"\n");
|
|
printer->Annotate("{", "}", oneof);
|
|
}
|
|
|
|
// Fields
|
|
for (int i = 0; i < descriptor_->field_count(); i++) {
|
|
printer->Print("public static final int $constant_name$ = $number$;\n",
|
|
"constant_name", FieldConstantName(descriptor_->field(i)),
|
|
"number", absl::StrCat(descriptor_->field(i)->number()));
|
|
printer->Annotate("constant_name", descriptor_->field(i));
|
|
field_generators_.get(descriptor_->field(i)).GenerateMembers(printer);
|
|
printer->Print("\n");
|
|
}
|
|
|
|
GenerateParseFromMethods(printer);
|
|
GenerateBuilder(printer);
|
|
|
|
if (HasRequiredFields(descriptor_)) {
|
|
// Memoizes whether the protocol buffer is fully initialized (has all
|
|
// required fields). 0 means false, 1 means true, and all other values
|
|
// mean not yet computed.
|
|
printer->Print("private byte memoizedIsInitialized = 2;\n");
|
|
}
|
|
|
|
printer->Print(
|
|
"@java.lang.Override\n"
|
|
"@java.lang.SuppressWarnings({\"unchecked\", \"fallthrough\"})\n"
|
|
"protected final java.lang.Object dynamicMethod(\n"
|
|
" com.google.protobuf.GeneratedMessageLite.MethodToInvoke method,\n"
|
|
" java.lang.Object arg0, java.lang.Object arg1) {\n"
|
|
" switch (method) {\n"
|
|
" case NEW_MUTABLE_INSTANCE: {\n"
|
|
" return new $classname$();\n"
|
|
" }\n",
|
|
"classname", name_resolver_->GetImmutableClassName(descriptor_));
|
|
|
|
printer->Indent();
|
|
printer->Indent();
|
|
|
|
printer->Print("case NEW_BUILDER: {\n");
|
|
|
|
printer->Indent();
|
|
GenerateDynamicMethodNewBuilder(printer);
|
|
printer->Outdent();
|
|
|
|
printer->Print(
|
|
"}\n"
|
|
"case BUILD_MESSAGE_INFO: {\n");
|
|
|
|
printer->Indent();
|
|
GenerateDynamicMethodNewBuildMessageInfo(printer);
|
|
printer->Outdent();
|
|
|
|
printer->Print(
|
|
"}\n"
|
|
"// fall through\n"
|
|
"case GET_DEFAULT_INSTANCE: {\n"
|
|
" return DEFAULT_INSTANCE;\n"
|
|
"}\n"
|
|
"case GET_PARSER: {\n"
|
|
// Generally one would use the lazy initialization holder pattern for
|
|
// manipulating static fields but that has exceptional cost on Android as
|
|
// it will generate an extra class for every message. Instead, use the
|
|
// double-check locking pattern which works just as well.
|
|
//
|
|
// The "parser" temporary mirrors the "PARSER" field to eliminate a read
|
|
// at the final return statement.
|
|
" com.google.protobuf.Parser<$classname$> parser = PARSER;\n"
|
|
" if (parser == null) {\n"
|
|
" synchronized ($classname$.class) {\n"
|
|
" parser = PARSER;\n"
|
|
" if (parser == null) {\n"
|
|
" parser =\n"
|
|
" new DefaultInstanceBasedParser<$classname$>(\n"
|
|
" DEFAULT_INSTANCE);\n"
|
|
" PARSER = parser;\n"
|
|
" }\n"
|
|
" }\n"
|
|
" }\n"
|
|
" return parser;\n",
|
|
"classname", name_resolver_->GetImmutableClassName(descriptor_));
|
|
|
|
printer->Outdent();
|
|
|
|
if (HasRequiredFields(descriptor_)) {
|
|
printer->Print(
|
|
"}\n"
|
|
"case GET_MEMOIZED_IS_INITIALIZED: {\n"
|
|
" return memoizedIsInitialized;\n"
|
|
"}\n"
|
|
"case SET_MEMOIZED_IS_INITIALIZED: {\n"
|
|
" memoizedIsInitialized = (byte) (arg0 == null ? 0 : 1);\n"
|
|
" return null;\n"
|
|
"}\n");
|
|
} else {
|
|
printer->Print(
|
|
"}\n"
|
|
"case GET_MEMOIZED_IS_INITIALIZED: {\n"
|
|
" return (byte) 1;\n"
|
|
"}\n"
|
|
"case SET_MEMOIZED_IS_INITIALIZED: {\n"
|
|
" return null;\n"
|
|
"}\n");
|
|
}
|
|
|
|
printer->Outdent();
|
|
printer->Print(
|
|
" }\n"
|
|
" throw new UnsupportedOperationException();\n"
|
|
"}\n"
|
|
"\n",
|
|
"classname", name_resolver_->GetImmutableClassName(descriptor_));
|
|
|
|
printer->Print(
|
|
"\n"
|
|
"// @@protoc_insertion_point(class_scope:$full_name$)\n",
|
|
"full_name", descriptor_->full_name());
|
|
|
|
// Carefully initialize the default instance in such a way that it doesn't
|
|
// conflict with other initialization.
|
|
printer->Print("private static final $classname$ DEFAULT_INSTANCE;\n",
|
|
"classname",
|
|
name_resolver_->GetImmutableClassName(descriptor_));
|
|
|
|
printer->Print(
|
|
"static {\n"
|
|
" $classname$ defaultInstance = new $classname$();\n"
|
|
" // New instances are implicitly immutable so no need to make\n"
|
|
" // immutable.\n"
|
|
" DEFAULT_INSTANCE = defaultInstance;\n"
|
|
// Register the default instance in a map. This map will be used by
|
|
// experimental runtime to lookup default instance given a class instance
|
|
// without using Java reflection.
|
|
" com.google.protobuf.GeneratedMessageLite.registerDefaultInstance(\n"
|
|
" $classname$.class, defaultInstance);\n"
|
|
"}\n"
|
|
"\n",
|
|
"classname", descriptor_->name());
|
|
|
|
printer->Print(
|
|
"public static $classname$ getDefaultInstance() {\n"
|
|
" return DEFAULT_INSTANCE;\n"
|
|
"}\n"
|
|
"\n",
|
|
"classname", name_resolver_->GetImmutableClassName(descriptor_));
|
|
|
|
// 'of' method for Wrappers
|
|
if (IsWrappersProtoFile(descriptor_->file())) {
|
|
printer->Print(
|
|
"public static $classname$ of($field_type$ value) {\n"
|
|
" return newBuilder().setValue(value).build();\n"
|
|
"}\n"
|
|
"\n",
|
|
"classname", name_resolver_->GetImmutableClassName(descriptor_),
|
|
"field_type", PrimitiveTypeName(GetJavaType(descriptor_->field(0))));
|
|
}
|
|
|
|
GenerateParser(printer);
|
|
|
|
// Extensions must be declared after the DEFAULT_INSTANCE is initialized
|
|
// because the DEFAULT_INSTANCE is used by the extension to lazily retrieve
|
|
// the outer class's FileDescriptor.
|
|
for (int i = 0; i < descriptor_->extension_count(); i++) {
|
|
ImmutableExtensionLiteGenerator(descriptor_->extension(i), context_)
|
|
.Generate(printer);
|
|
}
|
|
|
|
printer->Outdent();
|
|
printer->Print("}\n\n");
|
|
}
|
|
|
|
void ImmutableMessageLiteGenerator::GenerateDynamicMethodNewBuildMessageInfo(
|
|
io::Printer* printer) {
|
|
printer->Indent();
|
|
|
|
// Collect field info into a sequence of UTF-16 chars. It will be embedded
|
|
// as a Java string in the generated code.
|
|
std::vector<uint16_t> chars;
|
|
|
|
int flags = 0;
|
|
if (descriptor_->options().message_set_wire_format()) {
|
|
flags |= 0x2;
|
|
}
|
|
if (!context_->options().strip_nonfunctional_codegen) {
|
|
if (JavaGenerator::GetEdition(*descriptor_->file()) ==
|
|
Edition::EDITION_PROTO2) {
|
|
flags |= 0x1;
|
|
} else if (JavaGenerator::GetEdition(*descriptor_->file()) >=
|
|
Edition::EDITION_2023) {
|
|
flags |= 0x4;
|
|
}
|
|
}
|
|
|
|
WriteIntToUtf16CharSequence(flags, &chars);
|
|
WriteIntToUtf16CharSequence(descriptor_->field_count(), &chars);
|
|
|
|
if (descriptor_->field_count() == 0) {
|
|
printer->Print("java.lang.Object[] objects = null;");
|
|
} else {
|
|
// A single array of all fields (including oneof, oneofCase, hasBits).
|
|
printer->Print("java.lang.Object[] objects = new java.lang.Object[] {\n");
|
|
printer->Indent();
|
|
|
|
// Record the number of oneofs.
|
|
WriteIntToUtf16CharSequence(oneofs_.size(), &chars);
|
|
for (auto& kv : oneofs_) {
|
|
printer->Print(
|
|
"\"$oneof_name$_\",\n"
|
|
"\"$oneof_name$Case_\",\n",
|
|
"oneof_name", context_->GetOneofGeneratorInfo(kv.second)->name);
|
|
}
|
|
|
|
// Integers for bit fields.
|
|
int total_bits = 0;
|
|
for (int i = 0; i < descriptor_->field_count(); i++) {
|
|
total_bits +=
|
|
field_generators_.get(descriptor_->field(i)).GetNumBitsForMessage();
|
|
}
|
|
int total_ints = (total_bits + 31) / 32;
|
|
for (int i = 0; i < total_ints; i++) {
|
|
printer->Print("\"$bit_field_name$\",\n", "bit_field_name",
|
|
GetBitFieldName(i));
|
|
}
|
|
WriteIntToUtf16CharSequence(total_ints, &chars);
|
|
|
|
int map_count = 0;
|
|
int repeated_count = 0;
|
|
std::unique_ptr<const FieldDescriptor*[]> sorted_fields(
|
|
SortFieldsByNumber(descriptor_));
|
|
for (int i = 0; i < descriptor_->field_count(); i++) {
|
|
const FieldDescriptor* field = sorted_fields[i];
|
|
if (field->is_map()) {
|
|
map_count++;
|
|
} else if (field->is_repeated()) {
|
|
repeated_count++;
|
|
}
|
|
}
|
|
|
|
WriteIntToUtf16CharSequence(sorted_fields[0]->number(), &chars);
|
|
WriteIntToUtf16CharSequence(
|
|
sorted_fields[descriptor_->field_count() - 1]->number(), &chars);
|
|
WriteIntToUtf16CharSequence(descriptor_->field_count(), &chars);
|
|
WriteIntToUtf16CharSequence(map_count, &chars);
|
|
WriteIntToUtf16CharSequence(repeated_count, &chars);
|
|
|
|
std::vector<const FieldDescriptor*> fields_for_is_initialized_check;
|
|
for (int i = 0; i < descriptor_->field_count(); i++) {
|
|
if (descriptor_->field(i)->is_required() ||
|
|
(GetJavaType(descriptor_->field(i)) == JAVATYPE_MESSAGE &&
|
|
HasRequiredFields(descriptor_->field(i)->message_type()))) {
|
|
fields_for_is_initialized_check.push_back(descriptor_->field(i));
|
|
}
|
|
}
|
|
WriteIntToUtf16CharSequence(fields_for_is_initialized_check.size(), &chars);
|
|
|
|
for (int i = 0; i < descriptor_->field_count(); i++) {
|
|
const FieldDescriptor* field = sorted_fields[i];
|
|
field_generators_.get(field).GenerateFieldInfo(printer, &chars);
|
|
}
|
|
printer->Outdent();
|
|
printer->Print("};\n");
|
|
}
|
|
|
|
printer->Print("java.lang.String info =\n");
|
|
std::string line;
|
|
for (size_t i = 0; i < chars.size(); i++) {
|
|
uint16_t code = chars[i];
|
|
EscapeUtf16ToString(code, &line);
|
|
if (line.size() >= 80) {
|
|
printer->Print(" \"$string$\" +\n", "string", line);
|
|
line.clear();
|
|
}
|
|
}
|
|
printer->Print(" \"$string$\";\n", "string", line);
|
|
|
|
printer->Print("return newMessageInfo(DEFAULT_INSTANCE, info, objects);\n");
|
|
printer->Outdent();
|
|
}
|
|
|
|
// ===================================================================
|
|
|
|
void ImmutableMessageLiteGenerator::GenerateParseFromMethods(
|
|
io::Printer* printer) {
|
|
printer->Print(
|
|
"public static $classname$ parseFrom(\n"
|
|
" java.nio.ByteBuffer data)\n"
|
|
" throws com.google.protobuf.InvalidProtocolBufferException {\n"
|
|
" return com.google.protobuf.GeneratedMessageLite.parseFrom(\n"
|
|
" DEFAULT_INSTANCE, data);\n"
|
|
"}\n"
|
|
"public static $classname$ parseFrom(\n"
|
|
" java.nio.ByteBuffer data,\n"
|
|
" com.google.protobuf.ExtensionRegistryLite extensionRegistry)\n"
|
|
" throws com.google.protobuf.InvalidProtocolBufferException {\n"
|
|
" return com.google.protobuf.GeneratedMessageLite.parseFrom(\n"
|
|
" DEFAULT_INSTANCE, data, extensionRegistry);\n"
|
|
"}\n"
|
|
"public static $classname$ parseFrom(\n"
|
|
" com.google.protobuf.ByteString data)\n"
|
|
" throws com.google.protobuf.InvalidProtocolBufferException {\n"
|
|
" return com.google.protobuf.GeneratedMessageLite.parseFrom(\n"
|
|
" DEFAULT_INSTANCE, data);\n"
|
|
"}\n"
|
|
"public static $classname$ parseFrom(\n"
|
|
" com.google.protobuf.ByteString data,\n"
|
|
" com.google.protobuf.ExtensionRegistryLite extensionRegistry)\n"
|
|
" throws com.google.protobuf.InvalidProtocolBufferException {\n"
|
|
" return com.google.protobuf.GeneratedMessageLite.parseFrom(\n"
|
|
" DEFAULT_INSTANCE, data, extensionRegistry);\n"
|
|
"}\n"
|
|
"public static $classname$ parseFrom(byte[] data)\n"
|
|
" throws com.google.protobuf.InvalidProtocolBufferException {\n"
|
|
" return com.google.protobuf.GeneratedMessageLite.parseFrom(\n"
|
|
" DEFAULT_INSTANCE, data);\n"
|
|
"}\n"
|
|
"public static $classname$ parseFrom(\n"
|
|
" byte[] data,\n"
|
|
" com.google.protobuf.ExtensionRegistryLite extensionRegistry)\n"
|
|
" throws com.google.protobuf.InvalidProtocolBufferException {\n"
|
|
" return com.google.protobuf.GeneratedMessageLite.parseFrom(\n"
|
|
" DEFAULT_INSTANCE, data, extensionRegistry);\n"
|
|
"}\n"
|
|
"public static $classname$ parseFrom(java.io.InputStream input)\n"
|
|
" throws java.io.IOException {\n"
|
|
" return com.google.protobuf.GeneratedMessageLite.parseFrom(\n"
|
|
" DEFAULT_INSTANCE, input);\n"
|
|
"}\n"
|
|
"public static $classname$ parseFrom(\n"
|
|
" java.io.InputStream input,\n"
|
|
" com.google.protobuf.ExtensionRegistryLite extensionRegistry)\n"
|
|
" throws java.io.IOException {\n"
|
|
" return com.google.protobuf.GeneratedMessageLite.parseFrom(\n"
|
|
" DEFAULT_INSTANCE, input, extensionRegistry);\n"
|
|
"}\n"
|
|
"$parsedelimitedreturnannotation$\n"
|
|
"public static $classname$ parseDelimitedFrom(java.io.InputStream "
|
|
"input)\n"
|
|
" throws java.io.IOException {\n"
|
|
" return parseDelimitedFrom(DEFAULT_INSTANCE, input);\n"
|
|
"}\n"
|
|
"$parsedelimitedreturnannotation$\n"
|
|
"public static $classname$ parseDelimitedFrom(\n"
|
|
" java.io.InputStream input,\n"
|
|
" com.google.protobuf.ExtensionRegistryLite extensionRegistry)\n"
|
|
" throws java.io.IOException {\n"
|
|
" return parseDelimitedFrom(DEFAULT_INSTANCE, input, "
|
|
"extensionRegistry);\n"
|
|
"}\n"
|
|
"public static $classname$ parseFrom(\n"
|
|
" com.google.protobuf.CodedInputStream input)\n"
|
|
" throws java.io.IOException {\n"
|
|
" return com.google.protobuf.GeneratedMessageLite.parseFrom(\n"
|
|
" DEFAULT_INSTANCE, input);\n"
|
|
"}\n"
|
|
"public static $classname$ parseFrom(\n"
|
|
" com.google.protobuf.CodedInputStream input,\n"
|
|
" com.google.protobuf.ExtensionRegistryLite extensionRegistry)\n"
|
|
" throws java.io.IOException {\n"
|
|
" return com.google.protobuf.GeneratedMessageLite.parseFrom(\n"
|
|
" DEFAULT_INSTANCE, input, extensionRegistry);\n"
|
|
"}\n"
|
|
"\n",
|
|
"classname", name_resolver_->GetImmutableClassName(descriptor_),
|
|
"parsedelimitedreturnannotation",
|
|
context_->options().opensource_runtime
|
|
? ""
|
|
: "@com.google.protobuf.Internal.ProtoMethodMayReturnNull");
|
|
}
|
|
|
|
// ===================================================================
|
|
|
|
void ImmutableMessageLiteGenerator::GenerateBuilder(io::Printer* printer) {
|
|
printer->Print(
|
|
"public static Builder newBuilder() {\n"
|
|
" return (Builder) DEFAULT_INSTANCE.createBuilder();\n"
|
|
"}\n"
|
|
"public static Builder newBuilder($classname$ prototype) {\n"
|
|
" return DEFAULT_INSTANCE.createBuilder(prototype);\n"
|
|
"}\n"
|
|
"\n",
|
|
"classname", name_resolver_->GetImmutableClassName(descriptor_));
|
|
|
|
MessageBuilderLiteGenerator builderGenerator(descriptor_, context_);
|
|
builderGenerator.Generate(printer);
|
|
}
|
|
|
|
// ===================================================================
|
|
|
|
void ImmutableMessageLiteGenerator::GenerateDynamicMethodNewBuilder(
|
|
io::Printer* printer) {
|
|
printer->Print("return new Builder();\n");
|
|
}
|
|
|
|
// ===================================================================
|
|
|
|
void ImmutableMessageLiteGenerator::GenerateExtensionRegistrationCode(
|
|
io::Printer* printer) {
|
|
for (int i = 0; i < descriptor_->extension_count(); i++) {
|
|
ImmutableExtensionLiteGenerator(descriptor_->extension(i), context_)
|
|
.GenerateRegistrationCode(printer);
|
|
}
|
|
|
|
for (int i = 0; i < descriptor_->nested_type_count(); i++) {
|
|
ImmutableMessageLiteGenerator(descriptor_->nested_type(i), context_)
|
|
.GenerateExtensionRegistrationCode(printer);
|
|
}
|
|
}
|
|
|
|
// ===================================================================
|
|
void ImmutableMessageLiteGenerator::GenerateConstructor(io::Printer* printer) {
|
|
printer->Print("private $classname$() {\n", "classname", descriptor_->name());
|
|
printer->Indent();
|
|
|
|
// Initialize all fields to default.
|
|
GenerateInitializers(printer);
|
|
|
|
printer->Outdent();
|
|
printer->Print("}\n");
|
|
}
|
|
|
|
// ===================================================================
|
|
void ImmutableMessageLiteGenerator::GenerateParser(io::Printer* printer) {
|
|
printer->Print(
|
|
"private static volatile com.google.protobuf.Parser<$classname$> "
|
|
"PARSER;\n"
|
|
"\n"
|
|
"public static com.google.protobuf.Parser<$classname$> parser() {\n"
|
|
" return DEFAULT_INSTANCE.getParserForType();\n"
|
|
"}\n",
|
|
"classname", descriptor_->name());
|
|
}
|
|
|
|
// ===================================================================
|
|
void ImmutableMessageLiteGenerator::GenerateInitializers(io::Printer* printer) {
|
|
for (int i = 0; i < descriptor_->field_count(); i++) {
|
|
if (!IsRealOneof(descriptor_->field(i))) {
|
|
field_generators_.get(descriptor_->field(i))
|
|
.GenerateInitializationCode(printer);
|
|
}
|
|
}
|
|
}
|
|
|
|
void ImmutableMessageLiteGenerator::GenerateKotlinDsl(
|
|
io::Printer* printer) const {
|
|
printer->Print(
|
|
"@kotlin.OptIn"
|
|
"(com.google.protobuf.kotlin.OnlyForUseByGeneratedProtoCode::class)\n"
|
|
"@com.google.protobuf.kotlin.ProtoDslMarker\n");
|
|
printer->Print(
|
|
"public class Dsl private constructor(\n"
|
|
" private val _builder: $message$.Builder\n"
|
|
") {\n"
|
|
" public companion object {\n"
|
|
" @kotlin.jvm.JvmSynthetic\n"
|
|
" @kotlin.PublishedApi\n"
|
|
" internal fun _create(builder: $message$.Builder): Dsl = "
|
|
"Dsl(builder)\n"
|
|
" }\n"
|
|
"\n"
|
|
" @kotlin.jvm.JvmSynthetic\n"
|
|
" @kotlin.PublishedApi\n"
|
|
" internal fun _build(): $message$ = _builder.build()\n",
|
|
"message",
|
|
EscapeKotlinKeywords(name_resolver_->GetClassName(descriptor_, true)));
|
|
|
|
printer->Indent();
|
|
|
|
for (int i = 0; i < descriptor_->field_count(); i++) {
|
|
printer->Print("\n");
|
|
field_generators_.get(descriptor_->field(i))
|
|
.GenerateKotlinDslMembers(printer);
|
|
}
|
|
|
|
for (auto& kv : oneofs_) {
|
|
const OneofDescriptor* oneof = kv.second;
|
|
printer->Print(
|
|
"public val $oneof_name$Case: $message$.$oneof_capitalized_name$Case\n"
|
|
" @JvmName(\"get$oneof_capitalized_name$Case\")\n"
|
|
" get() = _builder.get$oneof_capitalized_name$Case()\n\n"
|
|
"public fun clear$oneof_capitalized_name$() {\n"
|
|
" _builder.clear$oneof_capitalized_name$()\n"
|
|
"}\n",
|
|
"oneof_name", context_->GetOneofGeneratorInfo(oneof)->name,
|
|
"oneof_capitalized_name",
|
|
context_->GetOneofGeneratorInfo(oneof)->capitalized_name, "message",
|
|
EscapeKotlinKeywords(name_resolver_->GetClassName(descriptor_, true)));
|
|
}
|
|
|
|
if (descriptor_->extension_range_count() > 0) {
|
|
GenerateKotlinExtensions(printer);
|
|
}
|
|
|
|
printer->Outdent();
|
|
printer->Print("}\n");
|
|
}
|
|
|
|
void ImmutableMessageLiteGenerator::GenerateKotlinMembers(
|
|
io::Printer* printer) const {
|
|
printer->Print("@kotlin.jvm.JvmName(\"-initialize$camelcase_name$\")\n",
|
|
"camelcase_name",
|
|
name_resolver_->GetKotlinFactoryName(descriptor_));
|
|
|
|
printer->Print(
|
|
"public inline fun $camelcase_name$(block: $message_kt$.Dsl.() -> "
|
|
"kotlin.Unit): $message$ =\n"
|
|
" $message_kt$.Dsl._create($message$.newBuilder()).apply { block() "
|
|
"}._build()\n",
|
|
"camelcase_name", name_resolver_->GetKotlinFactoryName(descriptor_),
|
|
"message_kt",
|
|
EscapeKotlinKeywords(
|
|
name_resolver_->GetKotlinExtensionsClassName(descriptor_)),
|
|
"message",
|
|
EscapeKotlinKeywords(name_resolver_->GetClassName(descriptor_, true)));
|
|
|
|
WriteMessageDocComment(printer, descriptor_, context_->options(),
|
|
/* kdoc */ true);
|
|
printer->Print("public object $name$Kt {\n", "name", descriptor_->name());
|
|
printer->Indent();
|
|
GenerateKotlinDsl(printer);
|
|
for (int i = 0; i < descriptor_->nested_type_count(); i++) {
|
|
if (IsMapEntry(descriptor_->nested_type(i))) continue;
|
|
ImmutableMessageLiteGenerator(descriptor_->nested_type(i), context_)
|
|
.GenerateKotlinMembers(printer);
|
|
}
|
|
printer->Outdent();
|
|
printer->Print("}\n");
|
|
}
|
|
|
|
void ImmutableMessageLiteGenerator::GenerateTopLevelKotlinMembers(
|
|
io::Printer* printer) const {
|
|
printer->Print(
|
|
"public inline fun $message$.copy(block: $message_kt$.Dsl.() -> "
|
|
"kotlin.Unit): $message$ =\n"
|
|
" $message_kt$.Dsl._create(this.toBuilder()).apply { block() "
|
|
"}._build()\n\n",
|
|
"message",
|
|
EscapeKotlinKeywords(name_resolver_->GetClassName(descriptor_, true)),
|
|
"message_kt",
|
|
name_resolver_->GetKotlinExtensionsClassNameEscaped(descriptor_));
|
|
|
|
for (int i = 0; i < descriptor_->nested_type_count(); i++) {
|
|
if (IsMapEntry(descriptor_->nested_type(i))) continue;
|
|
ImmutableMessageLiteGenerator(descriptor_->nested_type(i), context_)
|
|
.GenerateTopLevelKotlinMembers(printer);
|
|
}
|
|
|
|
GenerateKotlinOrNull(printer);
|
|
}
|
|
|
|
void ImmutableMessageLiteGenerator::GenerateKotlinOrNull(
|
|
io::Printer* printer) const {
|
|
// Generate getFieldOrNull getters for all optional message fields.
|
|
for (int i = 0; i < descriptor_->field_count(); i++) {
|
|
const FieldDescriptor* field = descriptor_->field(i);
|
|
if (field->has_presence() && GetJavaType(field) == JAVATYPE_MESSAGE) {
|
|
printer->Print(
|
|
"public val $full_classname$OrBuilder.$camelcase_name$OrNull: "
|
|
"$full_name$?\n"
|
|
" get() = if (has$name$()) get$name$() else null\n\n",
|
|
"full_classname",
|
|
EscapeKotlinKeywords(name_resolver_->GetClassName(descriptor_, true)),
|
|
"camelcase_name", context_->GetFieldGeneratorInfo(field)->name,
|
|
"full_name",
|
|
EscapeKotlinKeywords(
|
|
name_resolver_->GetImmutableClassName(field->message_type())),
|
|
"name", context_->GetFieldGeneratorInfo(field)->capitalized_name);
|
|
}
|
|
}
|
|
}
|
|
|
|
void ImmutableMessageLiteGenerator::GenerateKotlinExtensions(
|
|
io::Printer* printer) const {
|
|
std::string message_name =
|
|
EscapeKotlinKeywords(name_resolver_->GetClassName(descriptor_, true));
|
|
|
|
printer->Print(
|
|
"@Suppress(\"UNCHECKED_CAST\")\n"
|
|
"@kotlin.jvm.JvmSynthetic\n"
|
|
"public operator fun <T : kotlin.Any> get(extension: "
|
|
"com.google.protobuf.ExtensionLite<$message$, T>): T {\n"
|
|
" return if (extension.isRepeated) {\n"
|
|
" get(extension as com.google.protobuf.ExtensionLite<$message$, "
|
|
"kotlin.collections.List<*>>) as T\n"
|
|
" } else {\n"
|
|
" _builder.getExtension(extension)\n"
|
|
" }\n"
|
|
"}\n\n",
|
|
"message", message_name);
|
|
|
|
printer->Print(
|
|
"@kotlin.jvm.JvmSynthetic\n"
|
|
"@kotlin.OptIn"
|
|
"(com.google.protobuf.kotlin.OnlyForUseByGeneratedProtoCode::class)\n"
|
|
"@kotlin.jvm.JvmName(\"-getRepeatedExtension\")\n"
|
|
"public operator fun <E : kotlin.Any> get(\n"
|
|
" extension: com.google.protobuf.ExtensionLite<$message$, "
|
|
"kotlin.collections.List<E>>\n"
|
|
"): com.google.protobuf.kotlin.ExtensionList<E, $message$> {\n"
|
|
" return com.google.protobuf.kotlin.ExtensionList(extension, "
|
|
"_builder.getExtension(extension))\n"
|
|
"}\n\n",
|
|
"message", message_name);
|
|
|
|
printer->Print(
|
|
"@kotlin.jvm.JvmSynthetic\n"
|
|
"public operator fun contains(extension: "
|
|
"com.google.protobuf.ExtensionLite<$message$, *>): "
|
|
"Boolean {\n"
|
|
" return _builder.hasExtension(extension)\n"
|
|
"}\n\n",
|
|
"message", message_name);
|
|
|
|
printer->Print(
|
|
"@kotlin.jvm.JvmSynthetic\n"
|
|
"public fun clear(extension: "
|
|
"com.google.protobuf.ExtensionLite<$message$, *>) "
|
|
"{\n"
|
|
" _builder.clearExtension(extension)\n"
|
|
"}\n\n",
|
|
"message", message_name);
|
|
|
|
printer->Print(
|
|
"@kotlin.jvm.JvmSynthetic\n"
|
|
"public fun <T : kotlin.Any> setExtension(extension: "
|
|
"com.google.protobuf.ExtensionLite<$message$, T>, "
|
|
"value: T) {\n"
|
|
" _builder.setExtension(extension, value)\n"
|
|
"}\n\n",
|
|
"message", message_name);
|
|
|
|
printer->Print(
|
|
"@kotlin.jvm.JvmSynthetic\n"
|
|
"@Suppress(\"NOTHING_TO_INLINE\")\n"
|
|
"public inline operator fun <T : Comparable<T>> set(\n"
|
|
" extension: com.google.protobuf.ExtensionLite<$message$, T>,\n"
|
|
" value: T\n"
|
|
") {\n"
|
|
" setExtension(extension, value)\n"
|
|
"}\n\n",
|
|
"message", message_name);
|
|
|
|
printer->Print(
|
|
"@kotlin.jvm.JvmSynthetic\n"
|
|
"@Suppress(\"NOTHING_TO_INLINE\")\n"
|
|
"public inline operator fun set(\n"
|
|
" extension: com.google.protobuf.ExtensionLite<$message$, "
|
|
"com.google.protobuf.ByteString>,\n"
|
|
" value: com.google.protobuf.ByteString\n"
|
|
") {\n"
|
|
" setExtension(extension, value)\n"
|
|
"}\n\n",
|
|
"message", message_name);
|
|
|
|
printer->Print(
|
|
"@kotlin.jvm.JvmSynthetic\n"
|
|
"@Suppress(\"NOTHING_TO_INLINE\")\n"
|
|
"public inline operator fun <T : com.google.protobuf.MessageLite> set(\n"
|
|
" extension: com.google.protobuf.ExtensionLite<$message$, T>,\n"
|
|
" value: T\n"
|
|
") {\n"
|
|
" setExtension(extension, value)\n"
|
|
"}\n\n",
|
|
"message", message_name);
|
|
|
|
printer->Print(
|
|
"@kotlin.jvm.JvmSynthetic\n"
|
|
"public fun<E : kotlin.Any> com.google.protobuf.kotlin.ExtensionList<E, "
|
|
"$message$>.add(value: E) {\n"
|
|
" _builder.addExtension(this.extension, value)\n"
|
|
"}\n\n",
|
|
"message", message_name);
|
|
|
|
printer->Print(
|
|
"@kotlin.jvm.JvmSynthetic\n"
|
|
"@Suppress(\"NOTHING_TO_INLINE\")\n"
|
|
"public inline operator fun <E : kotlin.Any> "
|
|
"com.google.protobuf.kotlin.ExtensionList<E, "
|
|
"$message$>.plusAssign"
|
|
"(value: E) {\n"
|
|
" add(value)\n"
|
|
"}\n\n",
|
|
"message", message_name);
|
|
|
|
printer->Print(
|
|
"@kotlin.jvm.JvmSynthetic\n"
|
|
"public fun<E : kotlin.Any> com.google.protobuf.kotlin.ExtensionList<E, "
|
|
"$message$>.addAll(values: Iterable<E>) {\n"
|
|
" for (value in values) {\n"
|
|
" add(value)\n"
|
|
" }\n"
|
|
"}\n\n",
|
|
"message", message_name);
|
|
|
|
printer->Print(
|
|
"@kotlin.jvm.JvmSynthetic\n"
|
|
"@Suppress(\"NOTHING_TO_INLINE\")\n"
|
|
"public inline operator fun <E : kotlin.Any> "
|
|
"com.google.protobuf.kotlin.ExtensionList<E, "
|
|
"$message$>.plusAssign(values: "
|
|
"Iterable<E>) {\n"
|
|
" addAll(values)\n"
|
|
"}\n\n",
|
|
"message", message_name);
|
|
|
|
printer->Print(
|
|
"@kotlin.jvm.JvmSynthetic\n"
|
|
"public operator fun <E : kotlin.Any> "
|
|
"com.google.protobuf.kotlin.ExtensionList<E, "
|
|
"$message$>.set(index: Int, value: "
|
|
"E) {\n"
|
|
" _builder.setExtension(this.extension, index, value)\n"
|
|
"}\n\n",
|
|
"message", message_name);
|
|
|
|
printer->Print(
|
|
"@kotlin.jvm.JvmSynthetic\n"
|
|
"@Suppress(\"NOTHING_TO_INLINE\")\n"
|
|
"public inline fun com.google.protobuf.kotlin.ExtensionList<*, "
|
|
"$message$>.clear() {\n"
|
|
" clear(extension)\n"
|
|
"}\n\n",
|
|
"message", message_name);
|
|
}
|
|
|
|
} // namespace java
|
|
} // namespace compiler
|
|
} // namespace protobuf
|
|
} // namespace google
|
|
|
|
#include "google/protobuf/port_undef.inc"
|