Added JSON schema compiler support for serialized 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 code import Code
 from model import PropertyType
 import any_helper
 import cpp_util
 import model
 import schema_util
@@ skipping 235 matching lines @@
         .Append('scoped_ptr<base::DictionaryValue> value('
                 'new base::DictionaryValue());')
         .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)' %
+            c.Sblock('if (%s != %s) {' %
                 (prop.unix_name,
                  self._cpp_type_generator.GetEnumNoneValue(prop)))
           elif prop.type_ == PropertyType.CHOICES:
-            c.Sblock('if (%s_type != %s)' %
+            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)))
+            c.Sblock('if (%s.get()) {' % prop.unix_name)
+
+        if prop.type_ == prop.compiled_type:
+          c.Append('value->SetWithoutPathExpansion("%s", %s);' % (
+              prop.name,
+              self._CreateValueFromProperty(prop, 'this->' + prop.unix_name)))
+        else:
+          conversion_src = 'this->' + prop.unix_name
+          if prop.optional:
+            conversion_src = '*' + conversion_src
+          (c.Append('%s %s;' % (self._cpp_type_generator.GetType(prop),
+                                prop.unix_name))
+            .Append(cpp_util.GenerateCompiledTypeToTypeConversion(
+                self._cpp_type_generator.GetReferencedProperty(prop),
+                conversion_src,
+                prop.unix_name) + ';')
+            .Append('value->SetWithoutPathExpansion("%s", %s);' % (
+                prop.unix_name,
+                self._CreateValueFromProperty(prop, prop.unix_name)))
+          )
         if prop.optional:
-          c.Eblock();
+          c.Eblock('}');
     (c.Append()
       .Append('return value.Pass();')
       .Eblock('}')
     )
     return c
 
   def _GenerateFunction(self, cpp_namespace, function):
     """Generates the definitions for function structs.
     """
     c = Code()
@@ skipping 50 matching lines @@
         vardot = var + '->'
       else:
         vardot = var + '.'
       return ('base::BinaryValue::CreateWithCopiedBuffer(%sdata(), %ssize())' %
               (vardot, vardot))
     elif self._IsArrayOrArrayRef(prop):
       return '%s.release()' % self._util_cc_helper.CreateValueFromArray(
           self._cpp_type_generator.GetReferencedProperty(prop), var,
           prop.optional)
     elif self._IsFundamentalOrFundamentalRef(prop):
-      if prop.optional:
+      if prop.optional and prop.type_ == prop.compiled_type:
         var = '*' + var
       prop = self._cpp_type_generator.GetReferencedProperty(prop);
       return {
           PropertyType.STRING: 'base::Value::CreateStringValue(%s)',
           PropertyType.BOOLEAN: 'base::Value::CreateBooleanValue(%s)',
           PropertyType.INTEGER: 'base::Value::CreateIntegerValue(%s)',
           PropertyType.DOUBLE: 'base::Value::CreateDoubleValue(%s)',
       }[prop.type_] % var
     else:
       raise NotImplementedError('Conversion of %s to base::Value not '
@@ skipping 90 matching lines @@
 
     if self._IsFundamentalOrFundamentalRef(prop):
       if prop.optional:
         (c.Append('%(ctype)s temp;')
           .Append('if (!%s)' %
               cpp_util.GetAsFundamentalValue(
                   self._cpp_type_generator.GetReferencedProperty(prop),
                   value_var,
                   '&temp'))
           .Append('  return %(failure_value)s;')
-          .Append('%(dst)s->%(name)s.reset(new %(ctype)s(temp));')
         )
+        if prop.type_ != prop.compiled_type:
+          (c.Append('%(compiled_ctype)s temp2;')
+            .Append('if (!%s)' %

[mitchellwrosen, 2012/07/31 00:10:37]

Ugh, mis-aligned indents here. I'll fix it in a second, sorry about that.

+                 cpp_util.GenerateTypeToCompiledTypeConversion(
+                     self._cpp_type_generator.GetReferencedProperty(prop),
+                       'temp',
+                       'temp2'))
+              .Append('  return %(failure_value)s;')
+              .Append('%(dst)s->%(name)s.reset(new %(compiled_ctype)s(temp2));')
+          )
+        else:
+          c.Append('%(dst)s->%(name)s.reset(new %(ctype)s(temp));')
+
       else:
+        if prop.type_ == prop.compiled_type:
+          assignment_target = '&%s->%s' % (dst, prop.unix_name)
+        else:
+          c.Append('%(ctype)s temp;')
+          assignment_target = '&temp'
         (c.Append('if (!%s)' %
             cpp_util.GetAsFundamentalValue(
                 self._cpp_type_generator.GetReferencedProperty(prop),
                 value_var,
-                '&%s->%s' % (dst, prop.unix_name)))
+                assignment_target))
           .Append('  return %(failure_value)s;')
         )
+        if prop.type_ != prop.compiled_type:
+          (c.Append('if (!%s)' %
+              cpp_util.GenerateTypeToCompiledTypeConversion(
+                  self._cpp_type_generator.GetReferencedProperty(prop),
+                  'temp',
+                  '%s->%s' % (dst, prop.unix_name)))
+            .Append('  return %(failure_value)s;')
+          )
+
     elif self._IsObjectOrObjectRef(prop):
       if prop.optional:
         (c.Append('const base::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();')
         )
@@ skipping 64 matching lines @@
         (c.Append('%(dst)s->%(name)s.assign(binary_value->GetBuffer(),')
           .Append('                         binary_value->GetSize());')
          )
     else:
       raise NotImplementedError(prop.type_)
     c.Eblock('}')
     sub = {
         'value_var': value_var,
         'name': prop.unix_name,
         'dst': dst,
-        'failure_value': failure_value,
+        'failure_value': failure_value
     }
     if prop.type_ not in (PropertyType.CHOICES, PropertyType.ANY):
       sub['ctype'] = self._cpp_type_generator.GetType(prop)
+      sub['compiled_ctype'] = self._cpp_type_generator.GetCompiledType(prop)
       sub['value_type'] = cpp_util.GetValueType(self._cpp_type_generator
           .GetReferencedProperty(prop).type_)
     c.Substitute(sub)
     return c
 
   def _GenerateListValueToEnumArrayConversion(self, c, prop):
       """Appends code that converts a ListValue of string contstants to
       an array of enums in dst.
       Leaves dst, name, and failure_value unsubstituted.
 
@@ skipping 155 matching lines @@
                 'Create(%(declaration_list)s) {')
         .Append('scoped_ptr<base::ListValue> create_results('
                 'new base::ListValue());')
       )
       declaration_list = []
       for param in param_list:
         # We treat this argument as 'required' to avoid wrapping it in a
         # scoped_ptr if it's optional.
         param_copy = param.Copy()
         param_copy.optional = False
+        declaration_list.append("const %s" % cpp_util.GetParameterDeclaration(
+            param_copy, self._cpp_type_generator.GetCompiledType(param_copy)))
+        param_name = param_copy.unix_name
+        if param_copy.type_ != param_copy.compiled_type:
+          param_name = 'temp_' + param_name
+          (c.Append('%s %s;' % (self._cpp_type_generator.GetType(param_copy),
+                                param_name))
+            .Append(cpp_util.GenerateCompiledTypeToTypeConversion(
+                 param_copy,
+                 param_copy.unix_name,
+                 param_name) + ';')
+          )
         c.Append('create_results->Append(%s);' %
-            self._CreateValueFromProperty(param_copy, param_copy.unix_name))
-        declaration_list.append("const %s" % cpp_util.GetParameterDeclaration(
-            param_copy, self._cpp_type_generator.GetType(param_copy)))
+            self._CreateValueFromProperty(param_copy, param_name))
 
       c.Append('return create_results.Pass();')
       c.Eblock('}')
       if generate_to_json:
         c.Append()
         (c.Sblock('std::string %(function_scope)s::'
                   'ToJson(%(declaration_list)s) {')
           .Append('scoped_ptr<base::ListValue> create_results = '
                   '%(function_scope)s::Create(%(param_list)s);')
           .Append('std::string json;')
@@ skipping 40 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)