JSON Schema Compiler supports Enums as types.

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 109 matching lines @@
         .Append()
       )
       if type_.from_json:
         (c.Concat(self._GenerateTypePopulate(cpp_namespace, type_))
           .Append()
         )
       if type_.from_client:
         (c.Concat(self._GenerateTypeToValue(cpp_namespace, type_))
           .Append()
         )
+    elif self._IsEnumRef(type_):
+      c.Concat(self._GenerateCreateEnumTypeValue(cpp_namespace, type_))
+      c.Append()
     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 105 matching lines @@
           cpp_namespace)
         .Append('scoped_ptr<base::DictionaryValue> value('
                 'new base::DictionaryValue());')
         .Append()
     )
     for prop in type_.properties.values():
       if prop.type_ == PropertyType.ADDITIONAL_PROPERTIES:
         c.Append('value->MergeDictionary(&%s);' % prop.unix_name)
       else:
         if prop.optional:
-          if prop.type_ == PropertyType.ENUM:
+          if self._cpp_type_generator.IsEnumOrEnumRef(prop):
             c.Sblock('if (%s != %s) {' %
                 (prop.unix_name,
                  self._cpp_type_generator.GetEnumNoneValue(prop)))
           elif prop.type_ == PropertyType.CHOICES:
             c.Sblock('if (%s_type != %s) {' %
                 (prop.unix_name,
                  self._cpp_type_generator.GetEnumNoneValue(prop)))
           else:
             c.Sblock('if (%s.get()) {' % prop.unix_name)
 
@@ skipping 66 matching lines @@
     elif prop.type_ == PropertyType.ANY:
       return '%s.DeepCopy()' % self._any_helper.GetValue(prop, var)
     elif prop.type_ == PropertyType.ADDITIONAL_PROPERTIES:
       return '%s.DeepCopy()' % var
     elif prop.type_ == PropertyType.FUNCTION:
       if prop.optional:
         vardot = var + '->'
       else:
         vardot = var + '.'
       return '%sDeepCopy()' % vardot
-    elif prop.type_ == PropertyType.ENUM:
+    elif self._cpp_type_generator.IsEnumOrEnumRef(prop):
       return 'CreateEnumValue(%s).release()' % var
     elif prop.type_ == PropertyType.BINARY:
       if prop.optional:
         vardot = var + '->'
       else:
         vardot = var + '.'
       return ('base::BinaryValue::CreateWithCopiedBuffer(%sdata(), %ssize())' %
               (vardot, vardot))
     elif self._IsArrayOrArrayRef(prop):
       return '%s.release()' % self._util_cc_helper.CreateValueFromArray(
@@ skipping 100 matching lines @@
     dst: the object with |prop| as a member.
     failure_value: the value to return if |prop| cannot be extracted from
     |value_var|
     check_type: if true, will check if |value_var| is the correct
     base::Value::Type
     """
     c = Code()
     c.Sblock('{')
 
     if self._IsFundamentalOrFundamentalRef(prop):
-      if prop.optional:
-        (c.Append('%(ctype)s temp;')
-          .Append('if (!%s)' %
-              cpp_util.GetAsFundamentalValue(
-                  self._cpp_type_generator.GetReferencedProperty(prop),
-                  value_var,
-                  '&temp'))
-          .Append('  return %(failure_value)s;')
-        )
-        if prop.type_ != prop.compiled_type:
-          (c.Append('%(compiled_ctype)s temp2;')
-            .Append('if (!%s)' %
-                 cpp_util.GenerateTypeToCompiledTypeConversion(
-                     self._cpp_type_generator.GetReferencedProperty(prop),
-                     'temp',
-                     'temp2'))
-            .Append('  return %(failure_value)s;')
-            .Append('%(dst)s->%(name)s.reset(new %(compiled_ctype)s(temp2));')
-          )
-        else:
-          c.Append('%(dst)s->%(name)s.reset(new %(ctype)s(temp));')
+      self._GenerateFundamentalOrFundamentalRefPopulate(c, prop, value_var, dst)
+    elif self._IsObjectOrObjectRef(prop):
+      self._GenerateObjectOrObjectRefPopulate(c, prop)
+    elif prop.type_ == PropertyType.FUNCTION:
+      self._GenerateFunctionPopulate(c, prop)
+    elif prop.type_ == PropertyType.ANY:
+      self._GenerateAnyPopulate(c, prop, value_var, dst)
+    elif self._IsArrayOrArrayRef(prop):
+      self._GenerateArrayOrArrayRefPopulate(c, prop, dst)
+    elif prop.type_ == PropertyType.CHOICES:
+      self._GenerateChoicePopulate(c, prop, value_var, dst, failure_value)
+    elif self._cpp_type_generator.IsEnumOrEnumRef(prop):
+      self._GenerateEnumPopulate(c, prop, value_var)
+    elif prop.type_ == PropertyType.BINARY:
+      self._GenerateBinaryPopulate(c, prop)
+    else:
+      raise NotImplementedError(prop.type_)
+    c.Eblock('}')
+    sub = {
+        'value_var': value_var,
+        'name': prop.unix_name,
+        'dst': dst,
+        'failure_value': failure_value,
+    }
+    if prop.type_ not in (PropertyType.CHOICES, PropertyType.ANY):
+      sub['ctype'] = self._cpp_type_generator.GetType(prop)
+      sub['compiled_ctype'] = self._cpp_type_generator.GetCompiledType(prop)
+      sub['value_type'] = cpp_util.GetValueType(self._cpp_type_generator
+          .GetReferencedProperty(prop).type_)
+    c.Substitute(sub)
+    return c
 
-      else:
-        if prop.type_ == prop.compiled_type:
-          assignment_target = '&%s->%s' % (dst, prop.unix_name)
-        else:
-          c.Append('%(ctype)s temp;')
-          assignment_target = '&temp'
-        (c.Append('if (!%s)' %
+  def _GenerateFundamentalOrFundamentalRefPopulate(self,
+                                                   c,
+                                                   prop,
+                                                   value_var,
+                                                   dst):
+    if prop.optional:
+      (c.Append('%(ctype)s temp;')
+        .Append('if (!%s)' %
             cpp_util.GetAsFundamentalValue(
                 self._cpp_type_generator.GetReferencedProperty(prop),
                 value_var,
-                assignment_target))
+                '&temp'))
+        .Append('  return %(failure_value)s;')
+      )
+      if prop.type_ != prop.compiled_type:
+        (c.Append('%(compiled_ctype)s temp2;')
+          .Append('if (!%s)' %
+               cpp_util.GenerateTypeToCompiledTypeConversion(
+                   self._cpp_type_generator.GetReferencedProperty(prop),
+                   'temp',
+                   'temp2'))
+          .Append('  return %(failure_value)s;')
+          .Append('%(dst)s->%(name)s.reset(new %(compiled_ctype)s(temp2));')
+        )
+      else:
+        c.Append('%(dst)s->%(name)s.reset(new %(ctype)s(temp));')
+
+    else:
+      if prop.type_ == prop.compiled_type:
+        assignment_target = '&%s->%s' % (dst, prop.unix_name)
+      else:
+        c.Append('%(ctype)s temp;')
+        assignment_target = '&temp'
+      (c.Append('if (!%s)' %
+          cpp_util.GetAsFundamentalValue(
+              self._cpp_type_generator.GetReferencedProperty(prop),
+              value_var,
+              assignment_target))
+        .Append('  return %(failure_value)s;')
+      )
+      if prop.type_ != prop.compiled_type:
+        (c.Append('if (!%s)' %
+            cpp_util.GenerateTypeToCompiledTypeConversion(
+                self._cpp_type_generator.GetReferencedProperty(prop),
+                'temp',
+                '%s->%s' % (dst, prop.unix_name)))
           .Append('  return %(failure_value)s;')
         )
-        if prop.type_ != prop.compiled_type:
-          (c.Append('if (!%s)' %
-              cpp_util.GenerateTypeToCompiledTypeConversion(
-                  self._cpp_type_generator.GetReferencedProperty(prop),
-                  'temp',
-                  '%s->%s' % (dst, prop.unix_name)))
-            .Append('  return %(failure_value)s;')
-          )
 
-    elif self._IsObjectOrObjectRef(prop):
-      if prop.optional:
-        (c.Append('const base::DictionaryValue* dictionary = NULL;')
-          .Append('if (!%(value_var)s->GetAsDictionary(&dictionary))')
-          .Append('  return %(failure_value)s;')
-          .Append('scoped_ptr<%(ctype)s> temp(new %(ctype)s());')
-          .Append('if (!%(ctype)s::Populate(*dictionary, temp.get()))')
-          .Append('  return %(failure_value)s;')
-          .Append('%(dst)s->%(name)s = temp.Pass();')
-        )
-      else:
-        (c.Append('const base::DictionaryValue* dictionary = NULL;')
-          .Append('if (!%(value_var)s->GetAsDictionary(&dictionary))')
-          .Append('  return %(failure_value)s;')
-          .Append(
-              'if (!%(ctype)s::Populate(*dictionary, &%(dst)s->%(name)s))')
-          .Append('  return %(failure_value)s;')
-        )
-    elif prop.type_ == PropertyType.FUNCTION:
-      if prop.optional:
-        c.Append('%(dst)s->%(name)s.reset(new base::DictionaryValue());')
-    elif prop.type_ == PropertyType.ANY:
-      if prop.optional:
-        c.Append('%(dst)s->%(name)s.reset(new ' + any_helper.ANY_CLASS + '());')
-      c.Append(self._any_helper.Init(prop, value_var, dst) + ';')
-    elif self._IsArrayOrArrayRef(prop):
-      # util_cc_helper deals with optional and required arrays
-      (c.Append('const base::ListValue* list = NULL;')
-        .Append('if (!%(value_var)s->GetAsList(&list))')
-        .Append('  return %(failure_value)s;'))
-      if prop.item_type.type_ == PropertyType.ENUM:
-        self._GenerateListValueToEnumArrayConversion(c, prop)
-      else:
-        (c.Append('if (!%s)' % self._util_cc_helper.PopulateArrayFromList(
-              self._cpp_type_generator.GetReferencedProperty(prop), 'list',
-              dst + '->' + prop.unix_name, prop.optional))
-          .Append('  return %(failure_value)s;')
-        )
-    elif prop.type_ == PropertyType.CHOICES:
+  def _GenerateObjectOrObjectRefPopulate(self, c, prop):
+    if prop.optional:
+      (c.Append('const base::DictionaryValue* dictionary = NULL;')
+        .Append('if (!%(value_var)s->GetAsDictionary(&dictionary))')
+        .Append('  return %(failure_value)s;')
+        .Append('scoped_ptr<%(ctype)s> temp(new %(ctype)s());')
+        .Append('if (!%(ctype)s::Populate(*dictionary, temp.get()))')
+        .Append('  return %(failure_value)s;')
+        .Append('%(dst)s->%(name)s = temp.Pass();')
+      )
+    else:
+      (c.Append('const base::DictionaryValue* dictionary = NULL;')
+        .Append('if (!%(value_var)s->GetAsDictionary(&dictionary))')
+        .Append('  return %(failure_value)s;')
+        .Append(
+            'if (!%(ctype)s::Populate(*dictionary, &%(dst)s->%(name)s))')
+        .Append('  return %(failure_value)s;')
+      )
+
+  def _GenerateFunctionPopulate(self, c, prop):
+    if prop.optional:
+      c.Append('%(dst)s->%(name)s.reset(new base::DictionaryValue());')
+
+  def _GenerateAnyPopulate(self, c, prop, value_var, dst):
+    if prop.optional:
+      c.Append('%(dst)s->%(name)s.reset(new ' + any_helper.ANY_CLASS + '());')
+    c.Append(self._any_helper.Init(prop, value_var, dst) + ';')
+
+  def _GenerateArrayOrArrayRefPopulate(self, c, prop, dst):
+    # util_cc_helper deals with optional and required arrays
+    (c.Append('const base::ListValue* list = NULL;')
+      .Append('if (!%(value_var)s->GetAsList(&list))')
+      .Append('  return %(failure_value)s;'))
+    if prop.item_type.type_ == PropertyType.ENUM:
+      self._GenerateListValueToEnumArrayConversion(c, prop)
+    else:
+      (c.Append('if (!%s)' % self._util_cc_helper.PopulateArrayFromList(
+            self._cpp_type_generator.GetReferencedProperty(prop), 'list',
+            dst + '->' + prop.unix_name, prop.optional))
+        .Append('  return %(failure_value)s;')
+      )
+
+  def _GenerateChoicePopulate(self, c, prop, value_var, dst, failure_value):
       type_var = '%(dst)s->%(name)s_type'

[Yoyo Zhou, 2012/08/27 23:56:04]

nit: indent is 2

[chebert, 2012/08/28 21:31:14]

Done.

       c.Sblock('switch (%(value_var)s->GetType()) {')
       for choice in self._cpp_type_generator.ExpandParams([prop]):
         (c.Sblock('case %s: {' % cpp_util.GetValueType(
             self._cpp_type_generator.GetReferencedProperty(choice).type_))
             .Concat(self._GeneratePopulatePropertyFromValue(
                 choice, value_var, dst, failure_value, check_type=False))
             .Append('%s = %s;' %
                 (type_var,
                  self._cpp_type_generator.GetEnumValue(
                      prop, choice.type_.name)))
             .Append('break;')
           .Eblock('}')
         )
       (c.Append('default:')
         .Append('  return %(failure_value)s;')
       )
       c.Eblock('}')
-    elif prop.type_ == PropertyType.ENUM:
-      c.Sblock('{')
-      self._GenerateStringToEnumConversion(c, prop, value_var, 'enum_temp')
+
+  def _GenerateEnumTypePopulate(self, c, prop, value_var):

[Yoyo Zhou, 2012/08/27 23:56:04]

Is this ever called?

[chebert, 2012/08/28 21:31:14]

Nope. Deleting it.
On 2012/08/27 23:56:04, Yoyo Zhou wrote:

+    c.Sblock('{')
+    self._GenerateStringToEnumConversion(c, prop, value_var, 'enum_temp',
+        self._cpp_type_generator.GetReferencedProperty(prop).enum_values)

[Yoyo Zhou, 2012/08/27 23:56:04]

indentation is either 4 spaces after an open paren if no args after the paren,
or aligned with the paren.

[chebert, 2012/08/28 21:31:14]

Done.

+    if prop.optional:
+      c.Append('%(dst)s->%(name)s.reset(enum_temp);')
+    else:
       c.Append('%(dst)s->%(name)s = enum_temp;')
-      c.Eblock('}')
-    elif prop.type_ == PropertyType.BINARY:
-      (c.Append('if (!%(value_var)s->IsType(%(value_type)s))')
-        .Append('  return %(failure_value)s;')
-        .Append('const base::BinaryValue* binary_value =')
-        .Append('    static_cast<const base::BinaryValue*>(%(value_var)s);')
+    c.Eblock('}')
+
+  def _GenerateEnumPopulate(self, c, prop, value_var):
+    c.Sblock('{')
+    self._GenerateStringToEnumConversion(c, prop, value_var, 'enum_temp',
+        self._cpp_type_generator.GetReferencedProperty(prop).enum_values)

[Yoyo Zhou, 2012/08/27 23:56:04]

Seems like you can use this inside GenerateStringToEnumConversion and not have
to pass in the enum_values on the side.

[chebert, 2012/08/28 21:31:14]

Done.

+    c.Append('%(dst)s->%(name)s = enum_temp;')
+    c.Eblock('}')
+
+  def _GenerateBinaryPopulate(self, c, prop):
+    (c.Append('if (!%(value_var)s->IsType(%(value_type)s))')
+      .Append('  return %(failure_value)s;')
+      .Append('const base::BinaryValue* binary_value =')
+      .Append('    static_cast<const base::BinaryValue*>(%(value_var)s);')
+     )
+    if prop.optional:
+      (c.Append('%(dst)s->%(name)s.reset(')
+        .Append('    new std::string(binary_value->GetBuffer(),')
+        .Append('                    binary_value->GetSize()));')
        )
-      if prop.optional:
-        (c.Append('%(dst)s->%(name)s.reset(')
-          .Append('    new std::string(binary_value->GetBuffer(),')
-          .Append('                    binary_value->GetSize()));')
-         )
-      else:
-        (c.Append('%(dst)s->%(name)s.assign(binary_value->GetBuffer(),')
-          .Append('                         binary_value->GetSize());')
-         )
     else:
-      raise NotImplementedError(prop.type_)
-    c.Eblock('}')
-    sub = {
-        'value_var': value_var,
-        'name': prop.unix_name,
-        'dst': dst,
-        'failure_value': failure_value,
-    }
-    if prop.type_ not in (PropertyType.CHOICES, PropertyType.ANY):
-      sub['ctype'] = self._cpp_type_generator.GetType(prop)
-      sub['compiled_ctype'] = self._cpp_type_generator.GetCompiledType(prop)
-      sub['value_type'] = cpp_util.GetValueType(self._cpp_type_generator
-          .GetReferencedProperty(prop).type_)
-    c.Substitute(sub)
-    return c
+      (c.Append('%(dst)s->%(name)s.assign(binary_value->GetBuffer(),')
+        .Append('                         binary_value->GetSize());')
+       )
 
   def _GenerateListValueToEnumArrayConversion(self, c, prop):
       """Appends code that converts a ListValue of string contstants to
       an array of enums in dst.
       Leaves dst, name, and failure_value unsubstituted.
 
       c: the Code object that is being appended to.
       prop: the property that the code is populating.
       """
       accessor = '.'
       if prop.optional:
         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')
+      self._GenerateStringToEnumConversion(c, prop.item_type, '(*it)',
+          'enum_temp', prop.item_type.enum_values)

[Yoyo Zhou, 2012/08/27 23:56:04]

same comment about indent.

[chebert, 2012/08/28 21:31:14]

Done.

       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,
+                                      enum_values):
     """Appends code that converts a string to an enum.
     Leaves failure_value unsubstituded.

[Yoyo Zhou, 2012/08/27 23:56:04]

typo: unsubstituted

[chebert, 2012/08/28 21:31:14]

Done.

 
     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.
+    enum_values: the list of possible enum values.
     """
-    (c.Append('%s %s;' % (self._cpp_type_generator.GetType(prop), enum_temp))
+    (c.Append('%s %s;' % (self._cpp_type_generator.GetCompiledType(prop),
+                          enum_temp))
       .Append('std::string enum_as_string;')
       .Append('if (!%s->GetAsString(&enum_as_string))' % value_var)
       .Append('  return %(failure_value)s;')
     )
-    for i, enum_value in enumerate(prop.enum_values):
+    for i, enum_value in enumerate(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;')
     )
 
@@ skipping 44 matching lines @@
       .Append('return scoped_ptr<base::Value>();')
       .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

[Yoyo Zhou, 2012/08/27 23:56:04]

Sorry, but I'm confused as to how this function differs from
_GenerateCreateEnumValue below -- both generate functions with the same name and
signature, yet are different.

[chebert, 2012/08/28 21:31:14]

The plan I believe is to phase out the old-style of enums.

They are similar, but there are a few differences:
1) this one is not static
2) The enum type, since it is a PropertyType.TYPE, cannot be optional
3) the cpp_type_generator.GetEnumValue() does not differentiate between Types
and properties, so it doesn't know to use the classname instead of the
prop.unix_name

I was going to try to merge these two, but I haven't come up with a good way to
do it.

On 2012/08/27 23:56:04, Yoyo Zhou wrote:

+    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>();')
+      .Eblock('}')
+    )
+    return c
+
   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:
@@ skipping 96 matching lines @@
     return c
 
   def _InitializePropertyToDefault(self, prop, dst):
     """Initialize a model.Property to its default value inside an object.
 
     E.g for optional enum "state", generate dst->state = STATE_NONE;
 
     dst: Type*
     """
     c = Code()
-    if prop.type_ in (PropertyType.ENUM, PropertyType.CHOICES):
+    if (self._cpp_type_generator.IsEnumOrEnumRef(prop) or
+        prop.type_ == PropertyType.CHOICES):
       if prop.optional:
         prop_name = prop.unix_name
         if prop.type_ == PropertyType.CHOICES:
           prop_name = prop.unix_name + '_type'
         c.Append('%s->%s = %s;' % (
           dst,
           prop_name,
           self._cpp_type_generator.GetEnumNoneValue(prop)))
     return c
 
   def _IsObjectOrObjectRef(self, prop):
     """Determines if this property is an Object or is a ref to an Object.
     """
     return (self._cpp_type_generator.GetReferencedProperty(prop).type_ ==
         PropertyType.OBJECT)
 
   def _IsArrayOrArrayRef(self, prop):
     """Determines if this property is an Array or is a ref to an Array.
     """
     return (self._cpp_type_generator.GetReferencedProperty(prop).type_ ==
         PropertyType.ARRAY)
 
+  def _IsEnumRef(self, type_):
+    """Determines if this type is an Enum ref but not an Enum.
+    """
+    return (self._cpp_type_generator.IsEnumOrEnumRef(type_) and
+            type_ != PropertyType.ENUM)
+
   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)