Extensions Docs Server: Enum values do not show up if enum is a type

tools/json_schema_compiler/cc_generator.py

 # Copyright (c) 2012 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.
 
 from code import Code
 from model import PropertyType
 import any_helper
 import cpp_util
 import model
 import schema_util
@@ skipping 112 matching lines @@
         (c.Concat(self._GenerateTypePopulate(cpp_namespace, type_))
           .Append()
         )
       if type_.from_client:
         (c.Concat(self._GenerateTypeToValue(cpp_namespace, type_))
           .Append()
         )
     elif self._cpp_type_generator.IsEnumOrEnumRef(type_):
       c.Concat(self._GenerateCreateEnumTypeValue(cpp_namespace, type_))
       c.Append()
+      c.Concat(self._GenerateGetEnumTypeFromString(cpp_namespace, type_))
+      c.Append()

[not at google - send to devlin, 2012/09/14 01:44:51]

nit: style like

(c.Concat(...)
  .Append()
  .Concat(...)
  .Append())

[cduvall, 2012/09/17 22:07:46]

Done.

     c.Substitute({'classname': classname, 'namespace': cpp_namespace})
 
     return c
 
   def _GenerateInitializersAndBody(self, type_):
     items = []
     for prop in type_.properties.values():
       if prop.optional:
         continue
 
@@ skipping 70 matching lines @@
     """Generate the code to populate a single property in a type.
 
     src: base::DictionaryValue*
     dst: Type*
     """
     c = Code()
     value_var = prop.unix_name + '_value'
     c.Append('const base::Value* %(value_var)s = NULL;')
     if prop.optional:
       (c.Sblock(
-          'if (%(src)s->GetWithoutPathExpansion("%(key)s", &%(value_var)s)) {'
-        )
+          'if (%(src)s->GetWithoutPathExpansion("%(key)s", &%(value_var)s)) {')
         .Concat(self._GeneratePopulatePropertyFromValue(
             prop, value_var, dst, 'false'))
-        .Eblock('}')
-      )
+        .Eblock('}'))
+      if self._cpp_type_generator.IsEnumOrEnumRef(prop):
+        (c.Sblock('else {')

[not at google - send to devlin, 2012/09/14 01:44:51]

would be nice to generate style-guide compatible code here, like
} else {
rather than
}
else {
you might need to extend code.py to be able to do it, though. Maybe, err, Mblock
(M for Middle) or something.

[cduvall, 2012/09/17 22:07:46]

Done.

+          .Append('%%(dst)s->%%(name)s = %s;' %
+              self._cpp_type_generator.GetEnumNoneValue(prop))
+          .Eblock('}'))
     else:
       (c.Append(
           'if (!%(src)s->GetWithoutPathExpansion("%(key)s", &%(value_var)s))')
         .Append('  return false;')
         .Concat(self._GeneratePopulatePropertyFromValue(
             prop, value_var, dst, 'false'))
       )
     c.Append()
-    c.Substitute({'value_var': value_var, 'key': prop.name, 'src': src})
+    c.Substitute({
+      'value_var': value_var,
+      'key': prop.name,
+      'src': src,
+      'dst': dst,
+      'name': prop.unix_name
+    })
     return c
 
   def _GenerateTypeToValue(self, cpp_namespace, type_):
     """Generates a function that serializes the type into a
     |base::DictionaryValue|.
 
     E.g. for type "Foo" generates Foo::ToValue()
     """
     c = Code()
     (c.Sblock('scoped_ptr<base::DictionaryValue> %s::ToValue() const {' %
@@ skipping 393 matching lines @@
         c.Append('%(dst)s->%(name)s.reset(new std::vector<' + (
           self._cpp_type_generator.GetType(prop.item_type) + '>);'))
         accessor = '->'
       c.Sblock('for (ListValue::const_iterator it = list->begin(); '
                 'it != list->end(); ++it) {')
       self._GenerateStringToEnumConversion(
           c, prop.item_type, '(*it)', 'enum_temp')
       c.Append('%(dst)s->%(name)s' + accessor + 'push_back(enum_temp);')
       c.Eblock('}')
 
-  def _GenerateStringToEnumConversion(self,
-                                      c,
-                                      prop,
-                                      value_var,
-                                      enum_temp):
+  def _GenerateStringToEnumConversion(self, c, prop, value_var, enum_temp):
     """Appends code that converts a string to an enum.
     Leaves failure_value unsubstituted.
 
     c: the code that is appended to.
     prop: the property that the code is populating.
     value_var: the string value that is being converted.
     enum_temp: the name used to store the temporary enum value.
     """
-    (c.Append('%s %s;' % (self._cpp_type_generator.GetCompiledType(prop),
-                          enum_temp))
-      .Append('std::string enum_as_string;')
+    c.Append('%s %s = %s;' % (self._cpp_type_generator.GetCompiledType(prop),
+                              enum_temp,
+                              self._cpp_type_generator.GetEnumNoneValue(prop)))
+    (c.Append('std::string enum_as_string;')
       .Append('if (!%s->GetAsString(&enum_as_string))' % value_var)
-      .Append('  return %(failure_value)s;')
-    )
+      .Append('  return %(failure_value)s;'))
     for i, enum_value in enumerate(
           self._cpp_type_generator.GetReferencedProperty(prop).enum_values):
-      (c.Append(
-          ('if' if i == 0 else 'else if') +
-          '(enum_as_string == "%s")' % enum_value)
-        .Append('  ' + enum_temp + ' = %s;' % (
-            self._cpp_type_generator.GetEnumValue(prop, enum_value)))
-      )
-    (c.Append('else')
-      .Append('  return %(failure_value)s;')
-    )
+      (c.Append('if (enum_as_string == "%s")' % enum_value)
+        .Append('  %s = %s;' %
+             (enum_temp,
+             self._cpp_type_generator.GetEnumValue(prop, enum_value))))
+    (c.Append('if (%s == %s)' %
+        (enum_temp, self._cpp_type_generator.GetEnumNoneValue(prop)))
+     .Append('  return %(failure_value)s;'))
 
   def _GeneratePropertyFunctions(self, param_namespace, params):
     """Generate the functions for structures generated by a property such as
     CreateEnumValue for ENUMs and Populate/ToValue for Params/Results objects.
     """
     c = Code()
     for param in params:
       if param.type_ == PropertyType.OBJECT:
         c.Concat(self._GenerateType(
             param_namespace + '::' + cpp_util.Classname(param.name),
@@ skipping 23 matching lines @@
     )
     if prop.optional:
       c.Concat(self._GenerateReturnCase(
           self._cpp_type_generator.GetEnumNoneValue(prop),
           'scoped_ptr<base::Value>()'))
     for choice in self._cpp_type_generator.ExpandParams([prop]):
       c.Concat(self._GenerateReturnCase(
           self._cpp_type_generator.GetEnumValue(prop, choice.type_.name),
           'make_scoped_ptr<base::Value>(%s)' %
               self._CreateValueFromProperty(choice, choice.unix_name)))
-    (c.Eblock('}')
-      .Append('NOTREACHED();')
-      .Append('return scoped_ptr<base::Value>();')
+    (c.Append('default:')

[not at google - send to devlin, 2012/09/14 01:44:51]

so... is this a place where we legitimately don't know whether there's a NONE
value being generated? so we need to catch it in default too?

I mean, surely, we know. because we end up generating the code. question is how
much pain it is.

[cduvall, 2012/09/17 22:07:46]

Done.

+      .Append('  NOTREACHED();')
+      .Append('  return scoped_ptr<base::Value>();')
+      .Eblock('}')
       .Eblock('}')
       .Append()
       .Substitute({
         'cpp_namespace': cpp_namespace,
         'choice': cpp_util.Classname(prop.name)
       })
     )
     return c
 
   def _GenerateCreateEnumTypeValue(self, cpp_namespace, prop):
     """Generates CreateEnumValue() that returns the base::StringValue
     representation of an enum type.
     """
     c = Code()
     classname = cpp_util.Classname(schema_util.StripSchemaNamespace(prop.name))
     c.Sblock('scoped_ptr<base::Value> CreateEnumValue(%s %s) {' % (
         classname, classname.lower()))
     c.Sblock('switch (%s) {' % classname.lower())
 
     enum_prop = self._cpp_type_generator.GetReferencedProperty(prop)
     for enum_value in enum_prop.enum_values:
       c.Concat(self._GenerateReturnCase(
           '%s_%s' % (classname.upper(), enum_value.upper()),
           'scoped_ptr<base::Value>(base::Value::CreateStringValue("%s"))' %
           enum_value))
-    (c.Eblock('}')
-      .Append('NOTREACHED();')
-      .Append('return scoped_ptr<base::Value>();')
+    # We need a default case because all enum types have a *_NONE value, which
+    # is not handled in the other cases.

[not at google - send to devlin, 2012/09/14 01:44:51]

confused, can't you handle the NONE case explicitly then?

[cduvall, 2012/09/17 22:07:46]

Done.

+    (c.Append('default:')
+      .Append('  return scoped_ptr<base::Value>();')
       .Eblock('}')
+      .Eblock('}'))
+    return c
+
+  def _GenerateGetEnumTypeFromString(self, cpp_namespace, prop):
+    """Generates GetEnumFromString() which gets an enum from its string
+    representation.
+    """
+    c = Code()
+    classname = cpp_util.Classname(schema_util.StripSchemaNamespace(prop.name))
+    (c.Append('// static')
+      .Sblock('bool GetEnumFromString(const std::string& enum_string,'

[not at google - send to devlin, 2012/09/14 01:44:51]

does it make sense to return the enum directly? We have a _NONE value generated
for enums to use as the default case. out-param style methods are so awkward.

Also, since it's on the enum type already, FromString() is probably enough.

Also, seems like this should be using GenerateStringToEnumConverstion in some
way (or GSTEC should be modified to call this).

[cduvall, 2012/09/17 22:07:46]

Done.

+              ' %(class)s* %(var)s) {'))

[not at google - send to devlin, 2012/09/14 01:44:51]

how about generating a ToString(enum) too? seems useful. There might be code
around here somewhere for that.

[cduvall, 2012/09/17 22:07:46]

Done.

+    enum_prop = self._cpp_type_generator.GetReferencedProperty(prop)
+    for i, enum_value in enumerate(
+          self._cpp_type_generator.GetReferencedProperty(prop).enum_values):
+      # This is broken up into all ifs with no else ifs because we get
+      # "fatal error C1061: compiler limit : blocks nested too deeply"
+      # on Windows.

[not at google - send to devlin, 2012/09/14 01:44:51]

haha

+      (c.Sblock('if (enum_string == "%s") {' % enum_value)
+        .Append('*%%(var)s = %s_%s;' % (classname.upper(), enum_value.upper()))
+        .Append('return true;')
+        .Eblock('}'))
+    (c.Append('return false;')
+      .Eblock('}')
+      .Substitute({
+        'cpp_namespace': cpp_namespace,
+        'var': classname.lower(),
+        'class': classname
+      })
     )
     return c
 
   # TODO(chebert): This is basically the same as GenerateCreateEnumTypeValue().
   # The plan is to phase out the old-style enums, and make all enums into REF
   # types.
   def _GenerateCreateEnumValue(self, cpp_namespace, prop):
     """Generates CreateEnumValue() that returns the base::StringValue
     representation of an enum.
     """
     c = Code()
     c.Append('// static')
     c.Sblock('scoped_ptr<base::Value> %(cpp_namespace)s::CreateEnumValue('
              '%(arg)s) {')
     c.Sblock('switch (%s) {' % prop.unix_name)
     if prop.optional:
       c.Concat(self._GenerateReturnCase(
           self._cpp_type_generator.GetEnumNoneValue(prop),
           'scoped_ptr<base::Value>()'))
     for enum_value in prop.enum_values:
       c.Concat(self._GenerateReturnCase(
           self._cpp_type_generator.GetEnumValue(prop, enum_value),
           'scoped_ptr<base::Value>(base::Value::CreateStringValue("%s"))' %
           enum_value))
-    (c.Eblock('}')
-      .Append('NOTREACHED();')
-      .Append('return scoped_ptr<base::Value>();')
+    (c.Append('default:')

[not at google - send to devlin, 2012/09/14 01:44:51]

ditto

[cduvall, 2012/09/17 22:07:46]

Done.

+      .Append('  NOTREACHED();')
+      .Append('  return scoped_ptr<base::Value>();')
+      .Eblock('}')
       .Eblock('}')
       .Substitute({
         'cpp_namespace': cpp_namespace,
         'arg': cpp_util.GetParameterDeclaration(
             prop, self._cpp_type_generator.GetType(prop))
       })
     )
     return c
 
   def _GenerateReturnCase(self, case_value, return_value):
@@ skipping 105 matching lines @@
     """
     return (self._cpp_type_generator.GetReferencedProperty(prop).type_ ==
         PropertyType.ARRAY)
 
   def _IsFundamentalOrFundamentalRef(self, prop):
     """Determines if this property is a Fundamental type or is a ref to a
     Fundamental type.
     """
     return (self._cpp_type_generator.GetReferencedProperty(prop).type_.
         is_fundamental)