| // Copyright 2026 Google LLC |
| // |
| // Licensed under the Apache License, Version 2.0 (the "License"); |
| // you may not use this file except in compliance with the License. |
| // You may obtain a copy of the License at |
| // |
| // https://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS IS" BASIS, |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| // See the License for the specific language governing permissions and |
| // limitations under the License. |
| // |
| |
| #include "cbor/cbor_generator.h" |
| |
| #include <memory> |
| #include <string> |
| |
| #include "absl/base/no_destructor.h" |
| #include "absl/container/flat_hash_map.h" |
| #include "absl/container/flat_hash_set.h" |
| #include "absl/strings/ascii.h" |
| #include "absl/strings/match.h" |
| #include "absl/strings/str_cat.h" |
| #include "absl/strings/str_replace.h" |
| #include "absl/strings/string_view.h" |
| #include "cbor/tags.pb.h" |
| #include "google/protobuf/compiler/code_generator.h" |
| #include "google/protobuf/descriptor.h" |
| #include "google/protobuf/io/printer.h" |
| #include "google/protobuf/io/zero_copy_stream.h" |
| |
| namespace cbor { |
| namespace { |
| |
| std::string QualifiedCppName(const google::protobuf::Descriptor* descriptor) { |
| return absl::StrReplaceAll(descriptor->full_name(), {{".", "::"}}); |
| } |
| |
| absl::string_view StripProtoExtension(absl::string_view filename) { |
| if (absl::EndsWith(filename, ".proto")) { |
| return filename.substr(0, filename.size() - 6); |
| } |
| return filename; |
| } |
| |
| const cbor::Tags& GetTags(const google::protobuf::FieldDescriptor* field) { |
| if (field->options().HasExtension(cbor::tags)) { |
| return field->options().GetExtension(cbor::tags); |
| } |
| static const absl::NoDestructor<cbor::Tags> default_tags; |
| return *default_tags; |
| } |
| |
| std::string GetCborKey(const google::protobuf::FieldDescriptor* field) { |
| const auto& tags = GetTags(field); |
| if (!tags.name().empty()) { |
| return std::string(tags.name()); |
| } |
| return std::string(field->name()); |
| } |
| |
| const absl::flat_hash_map<google::protobuf::FieldDescriptor::Type, |
| absl::string_view>& |
| GetProtoTypeToCborType() { |
| static const absl::NoDestructor<absl::flat_hash_map< |
| google::protobuf::FieldDescriptor::Type, absl::string_view>> |
| proto_type_to_cbor_type({ |
| {google::protobuf::FieldDescriptor::TYPE_MESSAGE, "Map"}, |
| {google::protobuf::FieldDescriptor::TYPE_STRING, "String"}, |
| {google::protobuf::FieldDescriptor::TYPE_UINT64, "Uint64"}, |
| {google::protobuf::FieldDescriptor::TYPE_INT64, "Int64"}, |
| {google::protobuf::FieldDescriptor::TYPE_UINT32, "Uint64"}, |
| {google::protobuf::FieldDescriptor::TYPE_INT32, "Int64"}, |
| {google::protobuf::FieldDescriptor::TYPE_BOOL, "Bool"}, |
| {google::protobuf::FieldDescriptor::TYPE_FLOAT, "Float"}, |
| {google::protobuf::FieldDescriptor::TYPE_DOUBLE, "Double"}, |
| {google::protobuf::FieldDescriptor::TYPE_BYTES, "ByteString"}, |
| }); |
| return *proto_type_to_cbor_type; |
| } |
| |
| absl::string_view GetCborTypeName( |
| const google::protobuf::FieldDescriptor* field) { |
| const auto& tags = GetTags(field); |
| if (tags.type() != cbor::Tags::TYPE_UNSPECIFIED) { |
| switch (tags.type()) { |
| case cbor::Tags::TYPE_UINT: |
| return "Uint64"; |
| case cbor::Tags::TYPE_NINT: |
| return "Int64"; |
| case cbor::Tags::TYPE_BYTE_STRING: |
| return "ByteString"; |
| case cbor::Tags::TYPE_TEXT_STRING: |
| return "String"; |
| default: |
| break; |
| } |
| } |
| auto it = GetProtoTypeToCborType().find(field->type()); |
| if (it != GetProtoTypeToCborType().end()) { |
| return it->second; |
| } |
| return ""; |
| } |
| |
| void GenerateMessageHeader(const google::protobuf::Descriptor* desc, |
| google::protobuf::io::Printer& printer) { |
| printer.Emit({{"name", QualifiedCppName(desc)}}, R"cc( |
| absl::Status ToProto(const cbor::MapView& map, $name$* proto); |
| absl::StatusOr<std::unique_ptr<cppbor::Map>> FromProto(const $name$& proto); |
| absl::StatusOr<std::unique_ptr<cppbor::Map>> FromProto( |
| const $name$& proto, FromProtoOptions options); |
| )cc"); |
| for (int i = 0; i < desc->nested_type_count(); ++i) { |
| GenerateMessageHeader(desc->nested_type(i), printer); |
| } |
| } |
| |
| void GenerateToProtoBody(const google::protobuf::Descriptor* desc, |
| google::protobuf::io::Printer& printer) { |
| printer.Emit({{"name", QualifiedCppName(desc)}}, R"cc( |
| absl::Status ToProto(const cbor::MapView& map, $name$* proto) { |
| )cc"); |
| { |
| auto indent = printer.WithIndent(); |
| for (int i = 0; i < desc->field_count(); ++i) { |
| const auto* field = desc->field(i); |
| const auto& tags = GetTags(field); |
| if (tags.mode() == cbor::Tags::MODE_WRITE_ONLY || |
| tags.mode() == cbor::Tags::MODE_SKIP) { |
| continue; |
| } |
| |
| std::string key = GetCborKey(field); |
| printer.Emit(R"cc( |
| { |
| )cc"); |
| { |
| auto scope_indent = printer.WithIndent(); |
| if (field->is_repeated()) { |
| if (field->type() == |
| google::protobuf::FieldDescriptor::TYPE_MESSAGE) { |
| printer.Emit({{"field", field->name()}, {"key", key}}, R"cc( |
| auto array_view = map.GetOptionalArray("$key$"); |
| )cc"); |
| if (tags.is_required()) { |
| printer.Emit({{"key", key}}, R"cc( |
| if (!array_view.has_value()) { |
| return absl::InvalidArgumentError( |
| "Missing required field: " |
| "$key$"); |
| } |
| )cc"); |
| } |
| if (tags.disallow_empty()) { |
| printer.Emit({{"key", key}}, R"cc( |
| if (array_view.has_value() && array_view->size() == 0) { |
| return absl::InvalidArgumentError( |
| "Field $key$ cannot be " |
| "empty"); |
| } |
| )cc"); |
| } |
| printer.Emit({{"field", field->name()}}, R"cc( |
| if (array_view.has_value()) { |
| for (uint32_t i = 0; i < array_view->size(); ++i) { |
| ABSL_ASSIGN_OR_RETURN(auto item, array_view->GetMap(i)); |
| ABSL_RETURN_IF_ERROR(ToProto(std::move(item), proto->add_$field$())); |
| } |
| } |
| )cc"); |
| } else if (!GetCborTypeName(field).empty()) { |
| absl::string_view type = GetCborTypeName(field); |
| printer.Emit( |
| {{"field", field->name()}, {"key", key}, {"type", type}}, R"cc( |
| auto array_view = map.GetOptionalArray("$key$"); |
| )cc"); |
| if (tags.is_required()) { |
| printer.Emit({{"key", key}}, R"cc( |
| if (!array_view.has_value()) { |
| return absl::InvalidArgumentError( |
| "Missing required field: " |
| "$key$"); |
| } |
| )cc"); |
| } |
| if (tags.disallow_empty()) { |
| printer.Emit({{"key", key}}, R"cc( |
| if (array_view.has_value() && array_view->size() == 0) { |
| return absl::InvalidArgumentError( |
| "Field $key$ cannot be " |
| "empty"); |
| } |
| )cc"); |
| } |
| printer.Emit({{"field", field->name()}, {"type", type}}, R"cc( |
| if (array_view.has_value()) { |
| for (uint32_t i = 0; i < array_view->size(); ++i) { |
| ABSL_ASSIGN_OR_RETURN(auto item, array_view->Get$type$(i)); |
| proto->add_$field$(std::move(item)); |
| } |
| } |
| )cc"); |
| } |
| } else { |
| if (field->type() == |
| google::protobuf::FieldDescriptor::TYPE_MESSAGE) { |
| if (tags.is_required()) { |
| printer.Emit({{"field", field->name()}, {"key", key}}, R"cc( |
| auto map_view = map.GetOptionalMap("$key$"); |
| if (!map_view.has_value()) { |
| return absl::InvalidArgumentError( |
| "Missing required field: " |
| "$key$"); |
| } |
| ABSL_RETURN_IF_ERROR(ToProto(*map_view, proto->mutable_$field$())); |
| )cc"); |
| } else { |
| printer.Emit({{"field", field->name()}, {"key", key}}, R"cc( |
| auto map_view = map.GetOptionalMap("$key$"); |
| if (map_view.has_value()) { |
| ABSL_RETURN_IF_ERROR(ToProto(*map_view, proto->mutable_$field$())); |
| } |
| )cc"); |
| } |
| } else if (!GetCborTypeName(field).empty()) { |
| absl::string_view type = GetCborTypeName(field); |
| if (tags.is_required()) { |
| printer.Emit( |
| {{"field", field->name()}, {"key", key}, {"type", type}}, |
| R"cc( |
| auto val = map.GetOptional$type$("$key$"); |
| if (!val.has_value()) { |
| return absl::InvalidArgumentError( |
| "Missing required " |
| "field: $key$"); |
| } |
| proto->set_$field$(*val); |
| )cc"); |
| } else { |
| printer.Emit( |
| {{"field", field->name()}, {"key", key}, {"type", type}}, |
| R"cc( |
| auto val = map.GetOptional$type$("$key$"); |
| if (val.has_value()) { |
| proto->set_$field$(*val); |
| } |
| )cc"); |
| } |
| } |
| } |
| } |
| printer.Emit(R"cc( |
| } |
| )cc"); |
| } |
| printer.Emit(R"cc( |
| return absl::OkStatus(); |
| )cc"); |
| } |
| printer.Emit(R"cc( |
| } |
| )cc"); |
| for (int i = 0; i < desc->nested_type_count(); ++i) { |
| GenerateToProtoBody(desc->nested_type(i), printer); |
| } |
| } |
| |
| void GenerateFromProtoBody(const google::protobuf::Descriptor* desc, |
| google::protobuf::io::Printer& printer) { |
| printer.Emit({{"name", QualifiedCppName(desc)}}, R"cc( |
| absl::StatusOr<std::unique_ptr<cppbor::Map>> FromProto( |
| const $name$& proto) { |
| return FromProto(proto, FromProtoOptions{}); |
| } |
| |
| absl::StatusOr<std::unique_ptr<cppbor::Map>> FromProto( |
| const $name$& proto, FromProtoOptions options) { |
| auto map = std::make_unique<cppbor::Map>(); |
| )cc"); |
| { |
| auto indent = printer.WithIndent(); |
| for (int i = 0; i < desc->field_count(); ++i) { |
| const auto* field = desc->field(i); |
| const auto& tags = GetTags(field); |
| |
| if (tags.mode() == cbor::Tags::MODE_READ_ONLY || |
| tags.mode() == cbor::Tags::MODE_SKIP) { |
| continue; |
| } |
| |
| std::string key = GetCborKey(field); |
| if (field->is_repeated()) { |
| if (tags.is_required() && tags.disallow_empty()) { |
| printer.Emit({{"field", field->name()}, {"key", key}}, R"cc( |
| if (!options.skip_validation && proto.$field$_size() == 0) { |
| return absl::InvalidArgumentError("Field $key$ cannot be empty"); |
| } |
| )cc"); |
| } |
| if (tags.is_required()) { |
| printer.Emit(R"cc( |
| { |
| )cc"); |
| } else { |
| printer.Emit({{"field", field->name()}}, R"cc( |
| if (proto.$field$_size() > 0) { |
| )cc"); |
| } |
| |
| if (field->type() == google::protobuf::FieldDescriptor::TYPE_MESSAGE) { |
| printer.Emit({{"field", field->name()}, {"key", key}}, R"cc( |
| auto array = std::make_unique<cppbor::Array>(); |
| for (int i = 0; i < proto.$field$_size(); ++i) { |
| ABSL_ASSIGN_OR_RETURN(auto item, FromProto(proto.$field$(i))); |
| array->add(std::move(item)); |
| } |
| map->add("$key$", std::move(array)); |
| )cc"); |
| } else if (field->type() == |
| google::protobuf::FieldDescriptor::TYPE_BYTES) { |
| printer.Emit({{"field", field->name()}, {"key", key}}, R"cc( |
| auto array = std::make_unique<cppbor::Array>(); |
| for (int i = 0; i < proto.$field$_size(); ++i) { |
| array->add(cppbor::Bstr(std::string(proto.$field$(i)))); |
| } |
| map->add("$key$", std::move(array)); |
| )cc"); |
| } else if (field->type() == |
| google::protobuf::FieldDescriptor::TYPE_STRING) { |
| printer.Emit({{"field", field->name()}, {"key", key}}, R"cc( |
| auto array = std::make_unique<cppbor::Array>(); |
| for (int i = 0; i < proto.$field$_size(); ++i) { |
| array->add(cppbor::Tstr(std::string(proto.$field$(i)))); |
| } |
| map->add("$key$", std::move(array)); |
| )cc"); |
| } else if (field->type() == |
| google::protobuf::FieldDescriptor::TYPE_FLOAT) { |
| printer.Emit({{"field", field->name()}, {"key", key}}, R"cc( |
| auto array = std::make_unique<cppbor::Array>(); |
| for (int i = 0; i < proto.$field$_size(); ++i) { |
| array->add(cppbor::Float(proto.$field$(i))); |
| } |
| map->add("$key$", std::move(array)); |
| )cc"); |
| } else if (field->type() == |
| google::protobuf::FieldDescriptor::TYPE_DOUBLE) { |
| printer.Emit({{"field", field->name()}, {"key", key}}, R"cc( |
| auto array = std::make_unique<cppbor::Array>(); |
| for (int i = 0; i < proto.$field$_size(); ++i) { |
| array->add(cppbor::Double(proto.$field$(i))); |
| } |
| map->add("$key$", std::move(array)); |
| )cc"); |
| } else { |
| printer.Emit({{"field", field->name()}, {"key", key}}, R"cc( |
| auto array = std::make_unique<cppbor::Array>(); |
| for (int i = 0; i < proto.$field$_size(); ++i) { |
| array->add(proto.$field$(i)); |
| } |
| map->add("$key$", std::move(array)); |
| )cc"); |
| } |
| |
| printer.Emit(R"cc( |
| } |
| )cc"); |
| } else { |
| if (tags.is_required()) { |
| printer.Emit({{"field", field->name()}, {"key", key}}, R"cc( |
| if (!options.skip_validation && !proto.has_$field$()) { |
| return absl::InvalidArgumentError( |
| "Missing required field: " |
| "$key$"); |
| } |
| )cc"); |
| } |
| if (field->type() == google::protobuf::FieldDescriptor::TYPE_MESSAGE) { |
| printer.Emit({{"field", field->name()}, {"key", key}}, R"cc( |
| if (proto.has_$field$()) { |
| ABSL_ASSIGN_OR_RETURN(auto item, FromProto(proto.$field$())); |
| map->add("$key$", std::move(item)); |
| } |
| )cc"); |
| } else if (field->type() == |
| google::protobuf::FieldDescriptor::TYPE_BYTES) { |
| printer.Emit({{"field", field->name()}, {"key", key}}, R"cc( |
| if (proto.has_$field$()) { |
| map->add("$key$", cppbor::Bstr(std::string(proto.$field$()))); |
| } |
| )cc"); |
| } else if (field->type() == |
| google::protobuf::FieldDescriptor::TYPE_STRING) { |
| printer.Emit({{"field", field->name()}, {"key", key}}, R"cc( |
| if (proto.has_$field$()) { |
| map->add("$key$", cppbor::Tstr(std::string(proto.$field$()))); |
| } |
| )cc"); |
| } else if (field->type() == |
| google::protobuf::FieldDescriptor::TYPE_FLOAT) { |
| printer.Emit({{"field", field->name()}, {"key", key}}, R"cc( |
| if (proto.has_$field$()) { |
| map->add("$key$", cppbor::Float(proto.$field$())); |
| } |
| )cc"); |
| } else if (field->type() == |
| google::protobuf::FieldDescriptor::TYPE_DOUBLE) { |
| printer.Emit({{"field", field->name()}, {"key", key}}, R"cc( |
| if (proto.has_$field$()) { |
| map->add("$key$", cppbor::Double(proto.$field$())); |
| } |
| )cc"); |
| } else { |
| printer.Emit({{"field", field->name()}, {"key", key}}, R"cc( |
| if (proto.has_$field$()) { |
| map->add("$key$", proto.$field$()); |
| } |
| )cc"); |
| } |
| } |
| } |
| printer.Emit(R"cc( |
| return map; |
| )cc"); |
| } |
| printer.Emit(R"cc( |
| } |
| )cc"); |
| for (int i = 0; i < desc->nested_type_count(); ++i) { |
| GenerateFromProtoBody(desc->nested_type(i), printer); |
| } |
| } |
| |
| void CollectUsedDeps( |
| const google::protobuf::Descriptor* descriptor, |
| const google::protobuf::FileDescriptor* current_file, |
| absl::flat_hash_set<const google::protobuf::FileDescriptor*>& used_deps) { |
| for (int i = 0; i < descriptor->field_count(); ++i) { |
| const auto* f = descriptor->field(i); |
| if (f->type() == google::protobuf::FieldDescriptor::TYPE_MESSAGE) { |
| if (GetTags(f).mode() == cbor::Tags::MODE_SKIP) { |
| continue; |
| } |
| const auto* m = f->message_type(); |
| if (m->file() != current_file) { |
| used_deps.insert(m->file()); |
| } |
| } |
| } |
| for (int i = 0; i < descriptor->nested_type_count(); ++i) { |
| CollectUsedDeps(descriptor->nested_type(i), current_file, used_deps); |
| } |
| } |
| |
| void GenerateHeader(const google::protobuf::FileDescriptor* file, |
| absl::string_view base_name, |
| google::protobuf::compiler::GeneratorContext* context) { |
| std::unique_ptr<google::protobuf::io::ZeroCopyOutputStream> h_stream( |
| context->Open(absl::StrCat(base_name, ".cbor.h"))); |
| google::protobuf::io::Printer h_printer(h_stream.get()); |
| |
| std::string guard = absl::AsciiStrToUpper(absl::StrReplaceAll( |
| absl::StrCat(base_name, "_CBOR_H_"), {{"/", "_"}, {".", "_"}})); |
| h_printer.Emit({{"guard", guard}}, R"cc( |
| #ifndef $guard$ |
| #define $guard$ |
| )cc"); |
| |
| if (file->message_type_count() > 0) { |
| h_printer.Emit(R"cc( |
| #include <memory> |
| |
| #include "absl/status/status.h" |
| #include "absl/status/statusor.h" |
| #include "cbor/cbor.h" |
| #include "cbor/options.h" |
| #include "cppbor/cppbor.h" |
| )cc"); |
| } |
| |
| h_printer.Emit({{"base", base_name}}, R"cc( |
| #include "$base$.pb.h" |
| )cc"); |
| |
| for (int i = 0; i < file->public_dependency_count(); ++i) { |
| absl::string_view pub_base = |
| StripProtoExtension(file->public_dependency(i)->name()); |
| h_printer.Emit({{"pub", pub_base}}, R"cc( |
| #include "$pub$.cbor.h" // IWYU pragma: export |
| )cc"); |
| } |
| |
| h_printer.Emit(R"cc( |
| namespace cbor { |
| )cc"); |
| |
| for (int i = 0; i < file->message_type_count(); ++i) { |
| GenerateMessageHeader(file->message_type(i), h_printer); |
| } |
| |
| h_printer.Emit({{"guard", guard}}, R"cc( |
| } // namespace cbor |
| |
| #endif // $guard$ |
| )cc"); |
| } |
| |
| void GenerateCc(const google::protobuf::FileDescriptor* file, |
| absl::string_view base_name, |
| google::protobuf::compiler::GeneratorContext* context) { |
| std::unique_ptr<google::protobuf::io::ZeroCopyOutputStream> cc_stream( |
| context->Open(absl::StrCat(base_name, ".cbor.cc"))); |
| google::protobuf::io::Printer cc_printer(cc_stream.get()); |
| |
| cc_printer.Emit({{"base", base_name}}, R"cc( |
| #include "$base$.cbor.h" |
| )cc"); |
| |
| if (file->message_type_count() > 0) { |
| cc_printer.Emit({{"base", base_name}}, R"cc( |
| #include "$base$.pb.h" |
| #include "absl/status/status.h" |
| #include "absl/status/status_macros.h" |
| #include "absl/status/statusor.h" |
| #include "cbor/cbor.h" |
| #include "cppbor/cppbor.h" |
| )cc"); |
| } |
| |
| absl::flat_hash_set<const google::protobuf::FileDescriptor*> used_deps; |
| for (int i = 0; i < file->message_type_count(); ++i) { |
| CollectUsedDeps(file->message_type(i), file, used_deps); |
| } |
| |
| for (const auto* dep : used_deps) { |
| absl::string_view dep_base = StripProtoExtension(dep->name()); |
| cc_printer.Emit({{"dep", dep_base}}, R"cc( |
| #include "$dep$.cbor.h" |
| )cc"); |
| } |
| |
| cc_printer.Emit(R"cc( |
| namespace cbor { |
| )cc"); |
| |
| for (int i = 0; i < file->message_type_count(); ++i) { |
| GenerateToProtoBody(file->message_type(i), cc_printer); |
| GenerateFromProtoBody(file->message_type(i), cc_printer); |
| } |
| |
| cc_printer.Emit(R"cc( |
| } // namespace cbor |
| )cc"); |
| } |
| |
| } // namespace |
| |
| bool CborGenerator::Generate( |
| const google::protobuf::FileDescriptor* file, const std::string& parameter, |
| google::protobuf::compiler::GeneratorContext* context, |
| std::string* error) const { |
| absl::string_view base_name = StripProtoExtension(file->name()); |
| |
| GenerateHeader(file, base_name, context); |
| GenerateCc(file, base_name, context); |
| |
| return true; |
| } |
| |
| } // namespace cbor |
