JSON Schema Compiler now supports conversion from Choice to base::Value.

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 236 matching lines @@
         .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:
             c.Sblock('if (%s != %s)' %
                 (prop.unix_name,
-                    self._cpp_type_generator.GetEnumNoneValue(prop)))
+                 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)
         c.Append('value->SetWithoutPathExpansion("%s", %s);' % (
             prop.name,
             self._CreateValueFromProperty(prop, 'this->' + prop.unix_name)))
         if prop.optional:
           c.Eblock();
     (c.Append()
       .Append('return value.Pass();')
       .Eblock('}')
@@ skipping 18 matching lines @@
 
     # Results::Create function
     if function.callback:
       c.Concat(self._GenerateCreateCallbackArguments(
           "%s::Results" % cpp_namespace, function.callback))
 
     c.Substitute({'cpp_namespace': cpp_namespace})
 
     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:
-      (c.Append('case %s: {' % self._cpp_type_generator.GetEnumNoneValue(prop))
-        .Append('  return scoped_ptr<base::Value>();')
-        .Append('}')
-      )
-    for enum_value in prop.enum_values:
-      (c.Append('case %s: {' %
-          self._cpp_type_generator.GetEnumValue(prop, enum_value))
-        .Append('  return scoped_ptr<base::Value>('
-                'base::Value::CreateStringValue("%s"));' %
-                enum_value)
-        .Append('}')
-      )
-    (c.Append('default: {')
-      .Append('  return scoped_ptr<base::Value>();')
-      .Append('}')
-    )
-    c.Eblock('}')
-    c.Eblock('}')
-    c.Substitute({
-        'cpp_namespace': cpp_namespace,
-        'arg': cpp_util.GetParameterDeclaration(
-            prop, self._cpp_type_generator.GetType(prop))
-    })
-    return c
-
   def _CreateValueFromProperty(self, prop, var):
     """Creates a base::Value given a property. Generated code passes ownership
     to caller.
 
     var: variable or variable*
 
     E.g for std::string, generate base::Value::CreateStringValue(var)
     """
     if prop.type_ == PropertyType.CHOICES:
-      # CHOICES conversion not implemented. If needed, write something to
-      # generate a function that returns a scoped_ptr<base::Value> and put it in
-      # _GeneratePropertyFunctions, then use it here. Look at CreateEnumValue()
-      # for reference.
-      raise NotImplementedError(
-          'Conversion of CHOICES to base::Value not implemented')
-    if self._IsObjectOrObjectRef(prop):
+      return 'Get%sChoiceValue().release()' % cpp_util.Classname(prop.name)
+    elif self._IsObjectOrObjectRef(prop):
       if prop.optional:
         return '%s->ToValue().release()' % var
       else:
         return '%s.ToValue().release()' % var
     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.ENUM:
       return 'CreateEnumValue(%s).release()' % var
@@ skipping 265 matching lines @@
         c.Concat(self._GenerateType(
             param_namespace + '::' + cpp_util.Classname(param.name),
             param))
         c.Append()
       elif param.type_ == PropertyType.ARRAY:
         c.Concat(self._GeneratePropertyFunctions(
             param_namespace, [param.item_type]))
       elif param.type_ == PropertyType.CHOICES:
         c.Concat(self._GeneratePropertyFunctions(
             param_namespace, param.choices.values()))
+        if param.from_client:
+          c.Concat(self._GenerateGetChoiceValue(param_namespace, param))
       elif param.type_ == PropertyType.ENUM:
         c.Concat(self._GenerateCreateEnumValue(param_namespace, param))
         c.Append()
     return c
 
+  def _GenerateGetChoiceValue(self, cpp_namespace, prop):
+    """Generates Get<Type>ChoiceValue() that returns a scoped_ptr<base::Value>
+    representing the choice value.
+    """
+    c = Code()
+    (c.Sblock('scoped_ptr<base::Value> '
+              '%(cpp_namespace)s::Get%(choice)sChoiceValue() const {')
+      .Sblock('switch (%s_type) {' % prop.unix_name)
+    )
+    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>();')
+      .Eblock('}')
+      .Append()
+      .Substitute({
+        'cpp_namespace': cpp_namespace,
+        'choice': cpp_util.Classname(prop.name)
+      })
+    )
+    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:
+      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>();')
+      .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):
+    """Generates a single return case for a switch block.
+    """
+    c = Code()
+    (c.Append('case %s:' % case_value)
+      .Append('  return %s;' % return_value)
+    )
+    return c
+
   def _GenerateCreateCallbackArguments(self, function_scope, callback):
     """Generate all functions to create Value parameters for a callback.
 
     E.g for function "Bar", generate Bar::Results::Create
     E.g for event "Baz", generate Baz::Create
 
     function_scope: the function scope path, e.g. Foo::Bar for the function
     Foo::Bar::Baz().
     callback: the Function object we are creating callback arguments for.
     """
@@ skipping 59 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)