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 83 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 Capitalize(const std::string& str) {

[Primiano Tucci (use gerrit), 2016/08/31 09:04:07]

honestly I feel this is just overkill as you use only in one place.

Just easier if online 111 you do:

std::string name = field->camelcase_name();
name[0] = std::toupper(name[0])
name = "k" + name + "FieldNumer" (there should be no need for the explicit
std::string("k"))

+    std::string copy(str);
+    copy.at(0) = toupper(copy.at(0));
+    return copy;
+  }
+
+  inline std::string GetFieldNumberConstant(const FieldDescriptor* field) {
+    std::string name = field->camelcase_name();
+    if (!name.empty()) {
+      name = std::string("k") + Capitalize(name) + "FieldNumber";
+    } 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 107 matching lines @@
         "// //components/tracing/tools/proto_zero_plugin.\n";
     std::string guard = package_ + "_" + source_->name() + "_H_";
     UpperString(&guard);
     StripString(&guard, ".-/\\", '_');
 
     stub_h_->Print(
         "$greeting$\n"
         "#ifndef $guard$\n"
         "#define $guard$\n\n"
         "#include <stddef.h>\n"
         "#include <stdint.h>\n\n"

[Primiano Tucci (use gerrit), 2016/08/31 09:04:07]

I think you need also cctype for std::toupper

+        "#include <string>\n\n"
         "#include \"components/tracing/core/proto_zero_message.h\"\n",
         "greeting", greeting,
         "guard", guard);
     stub_cc_->Print(
         "$greeting$\n"
         "#include \"$name$.h\"\n",
         "greeting", greeting,
         "name", ProtoStubName(source_));
 
     // Print includes for public imports.
@@ skipping 186 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);
   }
 
+  void GenerateReflectionHelpers(const Descriptor* message) {
+    // Field numbers.

[Primiano Tucci (use gerrit), 2016/08/31 09:04:07]

I'd make this more clear:
// Field Numbers (e.g., kXXXFieldNumber = 42)

[kraynov, 2016/08/31 17:43:33]

Acknowledged.

+    if (message->field_count() > 0) {
+      stub_h_->Print("enum : int32_t {\n");

[Primiano Tucci (use gerrit), 2016/08/31 09:04:07]

just realized this, so far we used uint32_t for field numbers.

[kraynov, 2016/08/31 17:43:33]

Acknowledged.

+      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.
+    stub_h_->Print(
+        "static ::tracing::v2::proto::FieldReflection "
+        "GetFieldReflection(uint32_t field_id);");
+    stub_cc_->Print(
+        "::tracing::v2::proto::FieldReflection "
+        "$class$::GetFieldReflection(uint32_t field_id) {\n",
+        "class", GetCppClassName(message));
+    stub_cc_->Indent();
+    stub_cc_->Print("switch (field_id) {\n");
+    stub_cc_->Indent();
+
+    for (int i = 0; i < message->field_count(); ++i) {
+      const FieldDescriptor* field = message->field(i);
+      stub_cc_->Print(
+          "case $id$:\n"
+          "  return ::tracing::v2::proto::FieldReflection(\"$name$\", "

[Primiano Tucci (use gerrit), 2016/08/31 09:04:07]

Hmm this is going to be slow.
Can we make this just a lookup in a table where you have all the descriptors, so
this returns a FieldDescirptor*.
Something along the lines of http://pastebin.com/WPJWsnJH .
I think that if the table is fully const that should not require any static
initializers, as all the data will end up in the .rodata (or equivalent).
So this can generate just something like:

switch(field_id) {
  case 1:
    return &DescriptorTable[12];
  case 2: 
    return &DescriptorTable[7];
  etc

}

[kraynov, 2016/08/31 17:43:33]

Done.

+          "::tracing::v2::proto::ProtoType::kProtoType$type$,"
+          "$id$, $repeated$);\n",
+          "name", field->name(),
+          "type", Capitalize(FieldDescriptor::TypeName(field->type())),
+          "id", GetFieldNumberConstant(field),
+          "repeated", std::to_string(field->is_repeated()));
+    }
+    stub_cc_->Print(
+        "default:\n"
+        "  return ::tracing::v2::proto::FieldReflection::CreateInvalid();\n");
+
+    stub_cc_->Outdent();
+    stub_cc_->Print("}\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();
 
+    GenerateReflectionHelpers(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