Let json schema compiler handle using arrays 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 model import PropertyType
 import any_helper
 import code
 import cpp_util
 import model
 import sys
 import util_cc_helper
 
 class CCGenerator(object):
   """A .cc generator for a namespace.
   """
-  def __init__(self, namespace, cpp_type_generator):
+  def __init__(self, namespace, cpp_type_generator, referenced_schemas):

[Yoyo Zhou, 2012/04/12 00:54:57]

You can remove this since you don't use this anymore.

     self._cpp_type_generator = cpp_type_generator
+    self._referenced_schemas = referenced_schemas
     self._namespace = namespace
     self._target_namespace = (
         self._cpp_type_generator.GetCppNamespaceName(self._namespace))
     self._util_cc_helper = (
         util_cc_helper.UtilCCHelper(self._cpp_type_generator))
     self._any_helper = any_helper.AnyHelper()
 
   def Generate(self):
     """Generates a code.Code object with the .cc for a single namespace.
     """
@@ skipping 63 matching lines @@
       if type_.properties:
         raise NotImplementedError('\n'.join(model.GetModelHierarchy(type_)) +
             '\nCannot generate both functions and properties on a type')
       for function in type_.functions.values():
         (c.Concat(
             self._GenerateFunction(
                 cpp_namespace + '::' + cpp_util.Classname(function.name),
                 function))
           .Append()
         )
-    else:
+    elif type_.type_ == PropertyType.OBJECT:
       (c.Concat(self._GeneratePropertyFunctions(
           cpp_namespace, type_.properties.values()))
         .Sblock('%(namespace)s::%(classname)s()')
         .Concat(self._GenerateInitializersAndBody(type_))
         .Eblock('%(namespace)s::~%(classname)s() {}')
         .Append()
       )
       if type_.from_json:
         (c.Concat(self._GenerateTypePopulate(cpp_namespace, type_))
           .Append()
@@ skipping 202 matching lines @@
 
     E.g for std::string, generate 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<Value> and put it in
       # _GeneratePropertyFunctions, then use it here. Look at CreateEnumValue()
       # for reference.
       raise NotImplementedError(
           'Conversion of CHOICES to Value not implemented')
-    if prop.type_ in (PropertyType.REF, PropertyType.OBJECT):
+    if 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
-    elif prop.type_ == PropertyType.ARRAY:
+    elif self._IsArrayOrArrayRef(prop):
       return '%s.release()' % self._util_cc_helper.CreateValueFromArray(
-          prop, var)
+          self._cpp_type_generator.GetReferencedProperty(prop), var,
+          prop.optional)
     elif prop.type_.is_fundamental:
       if prop.optional:
         var = '*' + var
       return {
           PropertyType.STRING: 'Value::CreateStringValue(%s)',
           PropertyType.BOOLEAN: 'Value::CreateBooleanValue(%s)',
           PropertyType.INTEGER: 'Value::CreateIntegerValue(%s)',
           PropertyType.DOUBLE: 'Value::CreateDoubleValue(%s)',
       }[prop.type_] % var
     else:
@@ skipping 100 matching lines @@
           .Append('if (%s)' %
               cpp_util.GetAsFundamentalValue(prop, value_var, '&temp'))
           .Append('  %(dst)s->%(name)s.reset(new %(ctype)s(temp));')
         )
       else:
         (c.Append('if (!%s)' %
             cpp_util.GetAsFundamentalValue(
                 prop, value_var, '&%s->%s' % (dst, prop.unix_name)))
           .Append('return %(failure_value)s;')
         )
-    elif prop.type_ in (PropertyType.OBJECT, PropertyType.REF):
+    elif self._IsObjectOrObjectRef(prop):
       if prop.optional:
         (c.Append('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('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.ANY:
       if prop.optional:
         c.Append('%(dst)s->%(name)s.reset(new Any());')
       c.Append(self._any_helper.Init(prop, value_var, dst) + ';')
-    elif prop.type_ == PropertyType.ARRAY:
+    elif self._IsArrayOrArrayRef(prop):
       # util_cc_helper deals with optional and required arrays
       (c.Append('ListValue* list = NULL;')
         .Append('if (!%(value_var)s->GetAsList(&list))')
         .Append('  return %(failure_value)s;')
         .Append('if (!%s)' % self._util_cc_helper.PopulateArrayFromList(
-            prop, 'list', dst + '->' + prop.unix_name))
+            self._cpp_type_generator.GetReferencedProperty(prop), 'list',
+            dst + '->' + prop.unix_name, prop.optional))
         .Append('  return %(failure_value)s;')
       )
     elif prop.type_ == PropertyType.CHOICES:
       type_var = '%(dst)s->%(name)s_type'
       c.Sblock('switch (%(value_var)s->GetType()) {')
       for choice in self._cpp_type_generator.GetExpandedChoicesInParams([prop]):
-        (c.Sblock('case %s: {' % cpp_util.GetValueType(choice))
+        (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:')
@@ skipping 21 matching lines @@
       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['value_type'] = cpp_util.GetValueType(prop)
+      sub['value_type'] = cpp_util.GetValueType(self._cpp_type_generator
+          .GetReferencedProperty(prop).type_)
     c.Substitute(sub)
     return c
 
   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/Result objects.
     """
     c = code.Code()
     for param in params:
       if param.type_ == PropertyType.OBJECT:
@@ skipping 63 matching lines @@
     if prop.type_ in (PropertyType.ENUM, 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)