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):
     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._GetRef(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._GetRef(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._GetRef(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._GetRef(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._GetRef(prop).type_ == PropertyType.OBJECT
+
+  def _IsArrayOrArrayRef(self, prop):
+    """Determines if this property is an Array or is a ref to an Array.
+    """
+    return self._GetRef(prop).type_ == PropertyType.ARRAY
+
+  def _GetRef(self, prop):

[Yoyo Zhou, 2012/04/10 19:26:48]

I'm not sure this name is clear enoguh. How about GetReferencedType?

[cduvall, 2012/04/12 00:41:23]

This function is actually returning the whole property (see line 488), not just
the type, so I called it GetReferencedProperty. I also moved it into
cpp_type_generator, since I think it fits better there.

+    """Returns the item a $ref is referring to.

[Yoyo Zhou, 2012/04/10 19:26:48]

s/item/type/, and add a note on what it returns if prop is not a REF.

[cduvall, 2012/04/12 00:41:23]

Done. See previous comment.

+    """
+    if prop.type_ != PropertyType.REF:
+      return prop
+    if prop.ref_type in self._namespace.types.keys():
+      return self._namespace.types[prop.ref_type]
+    for namespace in self._referenced_schemas:
+      qualified_name = namespace + '.' + prop.ref_type
+      if qualified_name in self._cpp_type_generator._type_namespaces.keys():
+        return (self._cpp_type_generator._type_namespaces[qualified_name]

[Yoyo Zhou, 2012/04/10 19:26:48]

The _ is supposed to prefix private members, so you're getting at
_cpp_type_generator's private _type_namespaces. It seems like what you want is
cpp_type_generator._ResolveTypeNamespace to get the namespace; you can move this
into its public interface (removing the _) if you need to. But I would look
carefully to see if there's an even better fit that is already there.

[cduvall, 2012/04/12 00:41:23]

Done.

+            .types[prop.ref_type])
+    return prop