Support converting referenced enum array into string.

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 cpp_util
 import schema_util
 import util_cc_helper
 
@@ skipping 348 matching lines @@
         if underlying_type.property_type == PropertyType.ENUM:
           c.Sblock('if (%s != %s) {' %
               (prop_var,
                self._type_helper.GetEnumNoneValue(prop.type_)))
         else:
           c.Sblock('if (%s.get()) {' % prop_var)
 
       # ANY is a base::Value which is abstract and cannot be a direct member, so
       # it will always be a pointer.
       is_ptr = prop.optional or prop.type_.property_type == PropertyType.ANY
-      c.Append('value->SetWithoutPathExpansion("%s", %s);' % (
+      c.Cblock(self._CreateValueFromType(
+          'value->SetWithoutPathExpansion("' + prop.name + '", %s);',
           prop.name,
-          self._CreateValueFromType(cpp_namespace,
-                                    prop.type_,
-                                    prop_var,
-                                    is_ptr=is_ptr)))
+          prop.type_,
+          prop_var,
+          is_ptr=is_ptr))
 
       if prop.optional:
         c.Eblock('}')
 
     if type_.additional_properties is not None:
       if type_.additional_properties.property_type == PropertyType.ANY:
         c.Append('value->MergeDictionary(&additional_properties);')
       else:
         # Non-copyable types will be wrapped in a linked_ptr for inclusion in
         # maps, so we need to unwrap them.
         needs_unwrap = (
             not self._type_helper.IsCopyable(type_.additional_properties))
         cpp_type = self._type_helper.GetCppType(type_.additional_properties,
                                                 is_in_container=True)
         (c.Sblock('for (std::map<std::string, %s>::const_iterator it =' %
                       cpp_util.PadForGenerics(cpp_type))
           .Append('       additional_properties.begin();')
           .Append('   it != additional_properties.end(); ++it) {')
-          .Append('value->SetWithoutPathExpansion(it->first, %s);' %
-              self._CreateValueFromType(
-                  cpp_namespace,
-                  type_.additional_properties,
-                  '%sit->second' % ('*' if needs_unwrap else '')))
+          .Cblock(self._CreateValueFromType(
+              'value->SetWithoutPathExpansion(it->first, %s);',
+              type_.additional_properties.name,
+              type_.additional_properties,
+              '%sit->second' % ('*' if needs_unwrap else '')))
           .Eblock('}')
         )
 
     return (c.Append()
              .Append('return value.Pass();')
            .Eblock('}'))
 
   def _GenerateChoiceTypeToValue(self, cpp_namespace, type_):
     """Generates a function that serializes a choice-representing type
     into a base::Value.
     """
     c = Code()
     c.Sblock('scoped_ptr<base::Value> %s::ToValue() const {' % cpp_namespace)
     c.Append('scoped_ptr<base::Value> result;')
     for choice in type_.choices:
       choice_var = 'as_%s' % choice.unix_name
       (c.Sblock('if (%s) {' % choice_var)
           .Append('DCHECK(!result) << "Cannot set multiple choices for %s";' %
                       type_.unix_name)
-          .Append('result.reset(%s);' % self._CreateValueFromType(
-              cpp_namespace,
-              choice,
-              '*%s' % choice_var))
+          .Cblock(self._CreateValueFromType('result.reset(%s);',
+                                            choice.name,
+                                            choice,
+                                            '*%s' % choice_var))
         .Eblock('}')
       )
     (c.Append('DCHECK(result) << "Must set at least one choice for %s";' %
                   type_.unix_name)
       .Append('return result.Pass();')
       .Eblock('}')
     )
     return c
 
   def _GenerateFunction(self, function):
@@ skipping 36 matching lines @@
     (c.Append('namespace %s {' % event_namespace)
       .Append()
       .Cblock(self._GenerateEventNameConstant(None, event))
       .Cblock(self._GenerateCreateCallbackArguments(event_namespace,
                                                     None,
                                                     event))
       .Append('}  // namespace %s' % event_namespace)
     )
     return c
 
-  def _CreateValueFromType(self, cpp_namespace, type_, var, is_ptr=False):
+  def _CreateValueFromType(self, code, prop_name, type_, var, is_ptr=False):
     """Creates a base::Value given a type. Generated code passes ownership
     to caller.
 
     var: variable or variable*
 
     E.g for std::string, generate new base::StringValue(var)
     """
+    c = Code()
+    underlying_type = self._type_helper.FollowRef(type_)
+    if underlying_type.property_type == PropertyType.ARRAY:
+      # Enums are treated specially because C++ templating thinks that they're
+      # ints, but really they're strings.
+      underlying_item_type = self._type_helper.FollowRef(
+          underlying_type.item_type)
+      if underlying_item_type.property_type == PropertyType.ENUM:
+        if is_ptr:
+          vardot = '(%s)->' % var
+        else:
+          vardot = '(%s).' % var
+
+        maybe_namespace = ''
+        if type_.item_type.property_type == PropertyType.REF:
+          maybe_namespace = '%s::' % underlying_item_type.namespace.unix_name
+
+        enum_list_var = '%s_list' % prop_name
+        (c.Append('std::vector<std::string> %s;' % enum_list_var)
+          .Append('for (typename std::vector<%s>::const_iterator it = %sbegin();'
+              % (self._type_helper.GetCppType(underlying_item_type), vardot))
+          .Sblock('    it != %send(); ++it) {' % vardot)
+          .Append('%s.push_back(%sToString(*it));' % (enum_list_var,
+                                                      maybe_namespace))
+          .Eblock('}'))
+
+        if is_ptr:
+          var = 'scoped_ptr<std::vector<std::string> >(&%s)' % enum_list_var
+        else:
+          var = enum_list_var
+
+    c.Append(code % self._CreateValueFromTypeInternal(type_, var, is_ptr))
+    return c
+
+  def _CreateValueFromTypeInternal(self, type_, var, is_ptr):
     underlying_type = self._type_helper.FollowRef(type_)
     if (underlying_type.property_type == PropertyType.CHOICES or
         underlying_type.property_type == PropertyType.OBJECT):
       if is_ptr:
         return '(%s)->ToValue().release()' % var
       else:
         return '(%s).ToValue().release()' % var
     elif (underlying_type.property_type == PropertyType.ANY or
           underlying_type.property_type == PropertyType.FUNCTION):
       if is_ptr:
         vardot = '(%s)->' % var
       else:
         vardot = '(%s).' % var
       return '%sDeepCopy()' % vardot
     elif underlying_type.property_type == PropertyType.ENUM:
       classname = cpp_util.Classname(schema_util.StripNamespace(
           underlying_type.name))
       return 'new base::StringValue(%sToString(%s))' % (classname, var)
     elif underlying_type.property_type == PropertyType.BINARY:
       if is_ptr:
         vardot = var + '->'
       else:
         vardot = var + '.'
       return ('base::BinaryValue::CreateWithCopiedBuffer(%sdata(), %ssize())' %
               (vardot, vardot))
     elif underlying_type.property_type == PropertyType.ARRAY:
       return '%s.release()' % self._util_cc_helper.CreateValueFromArray(
-          cpp_namespace,
-          underlying_type,
           var,
           is_ptr)
     elif underlying_type.property_type.is_fundamental:
       if is_ptr:
         var = '*%s' % var
       if underlying_type.property_type == PropertyType.STRING:
         return 'new base::StringValue(%s)' % var
       else:
         return 'new base::FundamentalValue(%s)' % var
     else:
@@ skipping 430 matching lines @@
 
     (c.Sblock('scoped_ptr<base::ListValue> %(function_scope)s'
                   'Create(%(declaration_list)s) {')
       .Append('scoped_ptr<base::ListValue> create_results('
               'new base::ListValue());')
     )
     declaration_list = []
     for param in params:
       declaration_list.append(cpp_util.GetParameterDeclaration(
           param, self._type_helper.GetCppType(param.type_)))
-      c.Append('create_results->Append(%s);' % self._CreateValueFromType(
-          cpp_namespace,
-          param.type_,
-          param.unix_name))
+      c.Cblock(self._CreateValueFromType('create_results->Append(%s);',
+                                          param.name,
+                                          param.type_,
+                                          param.unix_name))
     c.Append('return create_results.Pass();')
     c.Eblock('}')
     c.Substitute({
         'function_scope': ('%s::' % function_scope) if function_scope else '',
         'declaration_list': ', '.join(declaration_list),
         'param_names': ', '.join(param.unix_name for param in params)
     })
     return c
 
   def _GenerateEventNameConstant(self, function_scope, event):
@@ skipping 40 matching lines @@
     if self._generate_error_messages:
       params = list(params) + ['base::string16* error']
     return ', '.join(str(p) for p in params)
 
   def _GenerateArgs(self, args):
     """Builds the argument list for a function, given an array of arguments.
     """
     if self._generate_error_messages:
       args = list(args) + ['error']
     return ', '.join(str(a) for a in args)