Tracing V2: Proto fields reflection.

components/tracing/tools/proto_zero_plugin/proto_zero_generator.cc

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "proto_zero_generator.h"
 
 #include <map>
 #include <memory>
 #include <set>
 #include <string>
@@ skipping 25 matching lines @@
 
 inline std::string ProtoStubName(const FileDescriptor* proto) {
   return StripSuffixString(proto->name(), ".proto") + ".pbzero";
 }
 
 class GeneratorJob {
  public:
   GeneratorJob(const FileDescriptor *file,
                Printer* stub_h_printer,
                Printer* stub_cc_printer)
-    : source_(file),
-      stub_h_(stub_h_printer),
-      stub_cc_(stub_cc_printer) {}
+      : source_(file), stub_h_(stub_h_printer), stub_cc_(stub_cc_printer) {
+  }
 
   bool GenerateStubs() {
     Preprocess();
     GeneratePrologue();
     for (const EnumDescriptor* enumeration: enums_)
       GenerateEnumDescriptor(enumeration);
     for (const Descriptor* message : messages_)
       GenerateMessageDescriptor(message);
     GenerateEpilogue();
     return error_.empty();
@@ skipping 35 matching lines @@
   // prohibited but not recommended in order to avoid name collisions.
   template <class T>
   inline std::string GetCppClassName(const T* descriptor, bool full = false) {
     std::string name = GetDescriptorName(descriptor);
     StripString(&name, ".", '_');
     if (full)
       name = full_namespace_prefix_ + name;
     return name;
   }
 
+  inline std::string GetFieldNumberConstant(const FieldDescriptor* field) {
+    std::string name = field->camelcase_name();
+    if (!name.empty()) {
+      name.at(0) = toupper(name.at(0));
+      name = std::string("k") + name + "FieldNumber";

[Primiano Tucci (use gerrit), 2016/09/02 16:49:51]

you can avoid std::string and just "k" here.

+    } else {
+      // Protoc allows fields like 'bool _ = 1'.
+      Abort("Empty field name in camel case notation.");
+    }
+    return name;
+  }
+
   // Small enums can be written faster without involving VarInt encoder.
   inline bool IsTinyEnumField(const FieldDescriptor* field) {
     if (field->type() != FieldDescriptor::TYPE_ENUM)
       return false;
     const EnumDescriptor* enumeration = field->enum_type();
 
     for (int i = 0; i < enumeration->value_count(); ++i) {
       int32_t value = enumeration->value(i)->number();
       if (value < 0 || value > 0x7F)
         return false;
@@ skipping 142 matching lines @@
     stub_h_->Print("\n");
 
     // Print includes for private imports to .cc file.
     for (const FileDescriptor* dependency : private_imports_) {
       stub_cc_->Print(
          "#include \"$name$.h\"\n",
          "name", ProtoStubName(dependency));
     }
     stub_cc_->Print("\n");
 
+    if (messages_.size() > 0) {
+      stub_cc_->Print(
+          "namespace {\n"
+          "  static const ::tracing::v2::proto::ProtoFieldDescriptor "
+          "kInvalidField = {\"\", "
+          "::tracing::v2::proto::ProtoFieldDescriptor::Type::TYPE_INVALID, "
+          "0, false};\n"
+          "}\n\n");
+    }
+
     // Print namespaces.
     for (const std::string& ns : namespaces_) {
       stub_h_->Print("namespace $ns$ {\n", "ns", ns);
       stub_cc_->Print("namespace $ns$ {\n", "ns", ns);
     }
     stub_h_->Print("\n");
     stub_cc_->Print("\n");
 
     // Print forward declarations.
     for (const Descriptor* message : referenced_messages_) {
@@ skipping 152 matching lines @@
         "$inner_class$* $outer_class$::$action$_$name$() {\n"
         "  return BeginNestedMessage<$inner_class$>($id$);\n"
         "}\n\n",
         "id", std::to_string(field->number()),
         "name", field->name(),
         "action", action,
         "inner_class", inner_class,
         "outer_class", outer_class);
   }
 
+  // TODO(kraynov): Implement reflection for enums.

[Primiano Tucci (use gerrit), 2016/09/02 16:49:51]

Not sure we need this. I'd remove this todo. If we need it I'll tell you :)

+  void GenerateReflectionForMessageFields(const Descriptor* message) {
+    const bool has_fields = (message->field_count() > 0);
+
+    // Field number constants.
+    if (has_fields) {
+      stub_h_->Print("enum : int32_t {\n");
+      stub_h_->Indent();
+
+      for (int i = 0; i < message->field_count(); ++i) {
+        const FieldDescriptor* field = message->field(i);
+        stub_h_->Print(
+            "$name$ = $id$,\n",
+            "name", GetFieldNumberConstant(field),
+            "id", std::to_string(field->number()));
+      }
+      stub_h_->Outdent();
+      stub_h_->Print("};\n");
+    }
+
+    // Fields reflection table.
+    stub_h_->Print(
+        "static const ::tracing::v2::proto::ProtoFieldDescriptor* "
+        "GetFieldDescriptor(uint32_t field_id);\n");
+
+    std::string class_name = GetCppClassName(message);
+    if (has_fields) {
+      stub_cc_->Print(
+          "static const ::tracing::v2::proto::ProtoFieldDescriptor "
+          "kFields_$class$[] = {\n",
+          "class", class_name);
+      stub_cc_->Indent();
+      for (int i = 0; i < message->field_count(); ++i) {
+        const FieldDescriptor* field = message->field(i);
+        std::string type_const = "TYPE_";
+        type_const += FieldDescriptor::TypeName(field->type());

[Primiano Tucci (use gerrit), 2016/09/02 16:49:51]

maybe you can do this in one line and to:
type_const += UpperString(FieldDescriptor::TypeName(field->type()))
if it fits in one line

+        UpperString(&type_const);
+        stub_cc_->Print(
+            "{\"$name$\", "
+            "::tracing::v2::proto::ProtoFieldDescriptor::Type::$type$, "
+            "$number$, $is_repeated$},\n",
+            "name", field->name(),
+            "type", type_const,
+            "number", std::to_string(field->number()),
+            "is_repeated", std::to_string(field->is_repeated()));
+      }
+      stub_cc_->Outdent();
+      stub_cc_->Print("};\n\n");
+    }
+
+    // Fields reflection getter.
+    stub_cc_->Print(
+        "const ::tracing::v2::proto::ProtoFieldDescriptor* "
+        "$class$::GetFieldDescriptor(uint32_t field_id) {\n",
+        "class", class_name);
+    stub_cc_->Indent();
+    if (message->field_count() > 0) {
+      stub_cc_->Print("switch (field_id) {\n");
+      stub_cc_->Indent();
+      for (int i = 0; i < message->field_count(); ++i) {
+        stub_cc_->Print(
+            "case $field$:\n"
+            "  return &kFields_$class$[$id$];\n",
+            "class", class_name,
+            "field", GetFieldNumberConstant(message->field(i)),
+            "id", std::to_string(i));
+      }
+      stub_cc_->Print(
+          "default:\n"
+          "  return &kInvalidField;\n");
+      stub_cc_->Outdent();
+      stub_cc_->Print("}\n");
+    } else {
+      stub_cc_->Print("return &kInvalidField;\n");
+    }
+    stub_cc_->Outdent();
+    stub_cc_->Print("}\n\n");
+  }
+
   void GenerateMessageDescriptor(const Descriptor* message) {
     stub_h_->Print(
         "class $name$ : public ::tracing::v2::ProtoZeroMessage {\n"
         " public:\n",
         "name", GetCppClassName(message));
     stub_h_->Indent();
 
+    GenerateReflectionForMessageFields(message);
+
     // Using statements for nested messages.
     for (int i = 0; i < message->nested_type_count(); ++i) {
       const Descriptor* nested_message = message->nested_type(i);
       stub_h_->Print(
           "using $local_name$ = $global_name$;\n",
           "local_name", nested_message->name(),
           "global_name", GetCppClassName(nested_message, true));
     }
 
     // Using statements for nested enums.
@@ skipping 13 matching lines @@
       for (int j = 0; j < nested_enum->value_count(); ++j) {
         const EnumValueDescriptor* value = nested_enum->value(j);
         stub_h_->Print(
             "static const $class$ $name$ = $full_name$;\n",
             "class", nested_enum->name(),
             "name", value->name(),
             "full_name", value_name_prefix + value->name());
       }
     }
 
-    // Field numbers.
-    if (message->field_count() > 0) {
-      stub_h_->Print("enum : int32_t {\n");
-      stub_h_->Indent();
-
-      for (int i = 0; i < message->field_count(); ++i) {
-        const FieldDescriptor* field = message->field(i);
-        std::string name = field->camelcase_name();
-        if (!name.empty()) {
-          name.at(0) = toupper(name.at(0));
-        } else {
-          // Protoc allows fields like 'bool _ = 1'.
-          Abort("Empty field name in camel case notation.");
-        }
-
-        stub_h_->Print(
-            "k$name$FieldNumber = $id$,\n",
-            "name", name,
-            "id", std::to_string(field->number()));
-      }
-      stub_h_->Outdent();
-      stub_h_->Print("};\n");
-    }
-
     // Field descriptors.
     for (int i = 0; i < message->field_count(); ++i) {
       const FieldDescriptor* field = message->field(i);
       if (field->is_packed()) {
         Abort("Packed repeated fields are not supported.");
         return;
       }
       if (field->type() != FieldDescriptor::TYPE_MESSAGE) {
         GenerateSimpleFieldDescriptor(field);
       } else {
@@ skipping 62 matching lines @@
 
   if (!job.GenerateStubs()) {
     *error = job.GetFirstError();
     return false;
   }
   return true;
 }
 
 }  // namespace proto
 }  // namespace tracing