JSON Schema Compiler supports Enums as types.

tools/json_schema_compiler/h_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 cpp_util
 import schema_util
 
 class HGenerator(object):
@@ skipping 140 matching lines @@
     # Generate the enums needed for any fields with "choices"
     for prop in props:
       if prop.type_ == PropertyType.CHOICES:
         enum_name = self._cpp_type_generator.GetChoicesEnumType(prop)
         c.Append('%s %s_type;' % (enum_name, prop.unix_name))
         c.Append()
 
     for prop in self._cpp_type_generator.ExpandParams(props):
       if prop.description:
         c.Comment(prop.description)
+      prop_name = prop.unix_name

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

Is this needed?

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

Done.

+      wrap_optional = not self._cpp_type_generator.IsEnumOrEnumRef(prop)

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

Can you document the reason for this in a comment?

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

Better yet, I will just get rid of it.
On 2012/08/27 23:56:04, Yoyo Zhou wrote:

       (c.Append('%s %s;' % (
-           self._cpp_type_generator.GetCompiledType(prop, wrap_optional=True),
-           prop.unix_name))
+           self._cpp_type_generator.GetCompiledType(prop,
+               wrap_optional=wrap_optional),
+           prop_name))
         .Append()
       )
     return c
 
   def _GenerateType(self, type_):
     """Generates a struct for a type.
     """
     classname = cpp_util.Classname(schema_util.StripSchemaNamespace(type_.name))
     c = Code()
 
     if type_.functions:
       c.Sblock('namespace %(classname)s {')
       for function in type_.functions.values():
         (c.Concat(self._GenerateFunction(function))
           .Append()
         )
       c.Eblock('}')
     elif type_.type_ == PropertyType.ARRAY:
       if type_.description:
         c.Comment(type_.description)
       c.Append('typedef std::vector<%(item_type)s> %(classname)s;')
       c.Substitute({'classname': classname, 'item_type':
           self._cpp_type_generator.GetCompiledType(type_.item_type,
                                                    wrap_optional=True)})
     elif type_.type_ == PropertyType.STRING:
       if type_.description:
         c.Comment(type_.description)
       c.Append('typedef std::string %(classname)s;')
+    elif type_.type_ == PropertyType.ENUM:
+      if type_.description:
+        c.Comment(type_.description)
+      c.Sblock('enum %(classname)s {')
+      for value in type_.enum_values:
+        c.Append('%s_%s,' % (classname.upper(), value.upper()))
+      (c.Eblock('};')
+        .Append()
+        .Append('scoped_ptr<base::Value> CreateEnumValue(%s %s);' %
+                (classname, classname.lower()))
+      )
     else:
       if type_.description:
         c.Comment(type_.description)
       (c.Sblock('struct %(classname)s {')
           .Append('~%(classname)s();')
           .Append('%(classname)s();')
           .Append()
           .Concat(self._GeneratePropertyStructures(type_.properties.values()))
           .Concat(self._GenerateFields(type_.properties.values()))
       )
@@ skipping 146 matching lines @@
 
   def _GenerateFunctionResults(self, callback):
     """Generates namespace for passing a function's result back.
     """
     c = Code()
     (c.Sblock('namespace Results {')
         .Concat(self._GenerateCreateCallbackArguments(callback))
       .Eblock('};')
     )
     return c