Add wider support to json_schema_compiler

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 code
 import cpp_util
 import util_cc_helper
 
 class CCGenerator(object):
@@ skipping 54 matching lines @@
       (c.Concat(self._GenerateFunction(function))
         .Append()
       )
     (c.Concat(self._cpp_type_generator.GetNamespaceEnd())
       .Concat(self._cpp_type_generator.GetRootNamespaceEnd())
       .Append()
     )
     # TODO(calamity): Events
     return c
 
-  def _GenerateType(self, cpp_namespace, type_, serializable=True):
+  def _GenerateType(self, cpp_namespace, type_):
     """Generates the function definitions for a type.
     """
     classname = cpp_util.Classname(type_.name)
     c = code.Code()
 
-    (c.Append('%(namespace)s::%(classname)s() {}')
+    (c.Concat(self._GeneratePropertyFunctions(
+        cpp_namespace, type_.properties.values()))
+      .Append('%(namespace)s::%(classname)s() {}')
       .Append('%(namespace)s::~%(classname)s() {}')
       .Append()
       .Concat(self._GenerateTypePopulate(cpp_namespace, type_))
       .Append()
     )
-    if serializable:
+    if type_.serializable:
       c.Concat(self._GenerateTypeToValue(cpp_namespace, type_))
     c.Append()
     c.Substitute({'classname': classname, 'namespace': cpp_namespace})
 
     return c
 
   def _GenerateTypePopulate(self, cpp_namespace, type_):
     """Generates the function for populating a type given a pointer to it.
     """
     classname = cpp_util.Classname(type_.name)
@@ skipping 24 matching lines @@
     dst: Type*
     """
     c = code.Code()
     value_var = prop.unix_name + '_value'
     c.Append('Value* %(value_var)s = NULL;')
     if prop.optional:
       (c.Sblock(
           'if (%(src)s->GetWithoutPathExpansion("%(key)s", &%(value_var)s)) {'
         )
         .Concat(self._GeneratePopulatePropertyFromValue(
-            prop, value_var, 'out', 'false'))
+            prop, value_var, dst, 'false'))
         .Eblock('}')
       )
     else:
       (c.Append(
           'if (!%(src)s->GetWithoutPathExpansion("%(key)s", &%(value_var)s))')
         .Append('  return false;')
         .Concat(self._GeneratePopulatePropertyFromValue(
-            prop, value_var, 'out', 'false'))
+            prop, value_var, dst, 'false'))
       )
     c.Append()
     c.Substitute({'value_var': value_var, 'key': prop.name, 'src': src})
     return c
 
   def _GenerateTypeToValue(self, cpp_namespace, type_):
     """Generates a function that serializes the type into a |DictionaryValue|.
     """
     c = code.Code()
     (c.Sblock('scoped_ptr<DictionaryValue> %s::ToValue() const {' %
           cpp_namespace)
         .Append('scoped_ptr<DictionaryValue> value(new DictionaryValue());')
         .Append()
     )
     for prop in type_.properties.values():
       c.Concat(self._CreateValueFromProperty(prop, prop.unix_name, 'value'))
     (c.Append()
       .Append('return value.Pass();')
       .Eblock('}')
     )
     return c
 
   def _CreateValueFromProperty(self, prop, var, dst):

[not at google - send to devlin, 2012/02/24 03:53:05]

just noticed that dst isn't documented, can you document this.

Also, what is this function "serialize"ing to? It's serializing to a Value
within a DictionaryValue given by |dst|... so mention that.

oh, kind of like the comment in GenerateTypeToValue.

TBH I think all these method comments need example code. It would be much easier
to understand that way. You can probably do that in a follow-up CL, but please
do it.

     """Generates code to serialize a single property in a type.
 
     prop: Property to create from
     var: variable with value to create from
     """
     c = code.Code()
-    if prop.type_ == PropertyType.ENUM:
-      c.Sblock('switch (%s) {' % var)
-      for enum_value in prop.enum_values:
-        (c.Append('case %s: {' %
-            self._cpp_type_generator.GetEnumValue(prop, enum_value))
-          .Append('  %s->SetWithoutPathExpansion('
-              '"%s", Value::CreateStringValue("%s"));' %
-              (dst, prop.name, enum_value))
-          .Append('  break;')
-          .Append('}')
-        )
-      # C++ requires the entire enum to be handled by a switch.
-      if prop.optional:
-        (c.Append('case %s: {' %
-            self._cpp_type_generator.GetEnumNoneValue(prop))
-          .Append('  break;')
-          .Append('}')
-        )
-      c.Eblock('}')
-    else:
-      if prop.optional:
+    if prop.optional:
+      if prop.type_ == PropertyType.ENUM:
+        c.Sblock('if (%s != %s)' %
+            (var, self._cpp_type_generator.GetEnumNoneValue(prop)))
+      else:
         c.Sblock('if (%s.get())' % var)

[not at google - send to devlin, 2012/02/24 03:53:05]

will this work for CHOICES?

[calamity, 2012/02/24 15:10:40]

No. There is currently no facility for turning a CHOICES Property into a Value.
Conveniently, I think choices are only ever used for Parameters or Results and
never in a type.

Commented this.

-      if prop.type_ == PropertyType.ARRAY:
-        c.Append('%s;' % self._util_cc_helper.PopulateDictionaryFromArray(
-            prop, var, prop.name, dst))
-      else:
-        c.Append('%s->SetWithoutPathExpansion("%s", %s);' %
-            (dst, prop.name, cpp_util.CreateValueFromSingleProperty(prop, var)))
+    c.Append('%s->SetWithoutPathExpansion("%s", %s);' % (
+        dst,
+        prop.name,
+        cpp_util.CreateValueFromSingleProperty(
+            prop, var, self._util_cc_helper)))
     return c
 
   def _GenerateFunction(self, function):
     """Generates the definitions for function structs.
     """
     classname = cpp_util.Classname(function.name)
     c = code.Code()
 
     # Params::Populate function
     if function.params:
-      for param in function.params:
-        if param.type_ == PropertyType.OBJECT:
-          param_namespace = '%s::Params::%s' % (classname,
-              cpp_util.Classname(param.name))
-          c.Concat(
-              self._GenerateType(param_namespace, param, serializable=False))
-          c.Append()
+      c.Concat(self._GeneratePropertyFunctions(classname + '::Params',
+          function.params))
       (c.Append('%(name)s::Params::Params() {}')
         .Append('%(name)s::Params::~Params() {}')
         .Append()
         .Concat(self._GenerateFunctionParamsCreate(function))
         .Append()
       )
 
     # Result::Create function
-    c.Concat(self._GenerateFunctionResultCreate(function))
+    if function.callback:
+      c.Concat(self._GenerateFunctionResultCreate(function))
 
     c.Substitute({'name': classname})
 
     return c
 
+  def _GenerateCreateEnumValue(self, cpp_namespace, prop):
+    """Generates a function that returns the Value representation of an enum.

[Yoyo Zhou, 2012/02/24 04:02:22]

Should this mention that they are string values?

[calamity, 2012/02/24 15:10:40]

Done.

+    """
+    c = code.Code()
+    c.Append('// static')
+    c.Sblock('scoped_ptr<Value> %(namespace)s::CreateEnumValue(%(arg)s) {')

[not at google - send to devlin, 2012/02/24 03:53:05]

call string substitution same name as variable, so %(cpp_namespace)s

[calamity, 2012/02/24 15:10:40]

Done.

+    c.Sblock('switch (%s) {' % prop.unix_name)
+    if prop.optional:
+      (c.Append('case %s: {' % self._cpp_type_generator.GetEnumNoneValue(prop))
+        .Append('  return scoped_ptr<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<Value>(Value::CreateStringValue("%s"));' %
+            enum_value)
+        .Append('}')
+      )
+    c.Eblock('}')
+    c.Eblock('}')
+    c.Substitute({
+        'namespace': cpp_namespace,
+        'arg': cpp_util.GetParameterDeclaration(
+            prop, self._cpp_type_generator.GetType(prop))
+    })
+    return c
+
   def _GenerateParamsCheck(self, function, var):
     """Generates a check for the correct number of arguments when creating
     Params.
     """
     c = code.Code()
     num_required = 0
     for param in function.params:
       if not param.optional:
         num_required += 1
     if num_required == len(function.params):
@@ skipping 64 matching lines @@
     should be performed before the code this generates.
 
     prop: the property the code is populating.
     value_var: a Value* that should represent |prop|.
     dst: the object with |prop| as a member.
     failure_value: the value to return if |prop| cannot be extracted from
     |value_var|
     check_type: if true, will check if |value_var| is the correct Value::Type
     """
     c = code.Code()
+    c.Append('// %s' % prop.name)

[not at google - send to devlin, 2012/02/24 03:53:05]

2 spaces between the // and the %s (sorry... yeah, it's just what people do)

[calamity, 2012/02/24 15:10:40]

Removed. This made the code uglier. I must have left it in by accident.

     c.Sblock('{')
 
-    if check_type:
+    if check_type and prop.type_ != PropertyType.CHOICES:
       (c.Append('if (!%(value_var)s->IsType(%(value_type)s))')
         .Append('  return %(failure_value)s;')
       )
 
     if prop.type_.is_fundamental:
       if prop.optional:
         (c.Append('%(ctype)s temp;')
           .Append('if (%s)' %
               cpp_util.GetAsFundamentalValue(prop, value_var, '&temp'))
           .Append('  %(dst)s->%(name)s.reset(new %(ctype)s(temp));')
@@ skipping 25 matching lines @@
     elif prop.type_ == PropertyType.ARRAY:
       # 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))
         .Append('  return %(failure_value)s;')
       )
     elif prop.type_ == PropertyType.CHOICES:
-      return self._GeneratePopulateChoices(prop, value_var, dst, failure_value)
+      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))
+            .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:')
+        .Append('  return %(failure_value)s;')
+      )
+      c.Eblock('}')
     elif prop.type_ == PropertyType.ENUM:
       (c.Append('std::string enum_temp;')
         .Append('if (!%(value_var)s->GetAsString(&enum_temp))')
         .Append('  return %(failure_value)s;')
       )
       for i, enum_value in enumerate(prop.enum_values):
         (c.Append(
             ('if' if i == 0 else 'else if') +
             '(enum_temp == "%s")' % enum_value)
           .Append('  %s->%s = %s;' % (
             dst,
             prop.unix_name,
             self._cpp_type_generator.GetEnumValue(prop, enum_value)))
         )
       (c.Append('else')
         .Append('  return %(failure_value)s;')
       )
     else:
       raise NotImplementedError(prop.type_)
     c.Eblock('}')
-    c.Substitute({
+    sub = {
         'value_var': value_var,
         'name': prop.unix_name,
         'dst': dst,
-        'ctype': self._cpp_type_generator.GetType(prop),
         'failure_value': failure_value,
-        'value_type': cpp_util.GetValueType(prop),
-    })
+    }
+    if prop.type_ != PropertyType.CHOICES:
+      sub['ctype'] = self._cpp_type_generator.GetType(prop)
+      sub['value_type'] = cpp_util.GetValueType(prop)
+    c.Substitute(sub)
     return c
 
-  def _GeneratePopulateChoices(self, prop, value_var, dst, failure_value):
-    """Generates the code to populate a PropertyType.CHOICES parameter or
-    property. The existence of data inside the Value* is assumed so checks for
-    existence should be performed before the code this generates.
-
-    prop: the property the code is populating..
-    value_var: a Value* that should represent |prop|.
-    dst: the object with |prop| as a member.
-    failure_value: the value to return if |prop| cannot be extracted from
-    |value_var|.
+  def _GeneratePropertyFunctions(self, param_namespace, params):
+    """Generate the structures required by a property such as functions OBJECT
+    properties and enum to Value conversion.

[not at google - send to devlin, 2012/02/24 03:53:05]

Ugh, I don't understand how the method name and comment relate to each other.
Also the comment doesn't parse to me.

[calamity, 2012/02/24 15:10:40]

Done.

     """
-    type_var = '%s->%s_type' % (dst, prop.unix_name)
-
     c = code.Code()
-    c.Sblock('switch (%s->GetType()) {' % value_var)
-    for choice in self._cpp_type_generator.GetExpandedChoicesInParams([prop]):
-      (c.Sblock('case %s: {' % cpp_util.GetValueType(choice))
-          .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:')
-      .Append('  return %s;' % failure_value)
-    )
-    c.Eblock('}')
+    for param in params:
+      if param.type_ == PropertyType.OBJECT:
+        c.Concat(self._GenerateType(
+            param_namespace + '::' + cpp_util.Classname(param.name),
+            param))
+        c.Append()
+      elif param.type_ == PropertyType.ENUM:
+        c.Concat(self._GenerateCreateEnumValue(param_namespace, param))
+        c.Append()
     return c
 
   def _GenerateFunctionResultCreate(self, function):
     """Generate function to create a Result given the return value.
     """
     classname = cpp_util.Classname(function.name)
     c = code.Code()
     params = function.callback.params
 
     if not params:
       (c.Append('Value* %s::Result::Create() {' % classname)
         .Append('  return Value::CreateNullValue();')
         .Append('}')
       )
     else:
+      expanded_params = self._cpp_type_generator.GetExpandedChoicesInParams(
+          params)
+      c.Concat(self._GeneratePropertyFunctions(
+              classname + '::Result', expanded_params))

[not at google - send to devlin, 2012/02/24 03:53:05]

too much indentation

[calamity, 2012/02/24 15:10:40]

Done.

+
       # If there is a single parameter, this is straightforward. However, if
       # the callback parameter is of 'choices', this generates a Create method
       # for each choice. This works because only 1 choice can be returned at a
       # time.
-      for param in self._cpp_type_generator.GetExpandedChoicesInParams(params):
+      for param in expanded_params:
         # 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
         c.Sblock('Value* %(classname)s::Result::Create(const %(arg)s) {')
-        if param_copy.type_ == PropertyType.ARRAY:
-          (c.Append('ListValue* value = new ListValue();')
-            .Append('%s;' % self._util_cc_helper.PopulateListFromArray(
-                param_copy, param_copy.unix_name, 'value'))
-            .Append('return value;')
-          )
-        else:
-          c.Append('return %s;' %
-              cpp_util.CreateValueFromSingleProperty(param_copy,
-                  param_copy.unix_name))
+        c.Append('return %s;' %
+            cpp_util.CreateValueFromSingleProperty(param_copy,
+                param_copy.unix_name, self._util_cc_helper))
+        c.Eblock('}')
         c.Substitute({'classname': classname,
             'arg': cpp_util.GetParameterDeclaration(
                 param_copy, self._cpp_type_generator.GetType(param_copy))
         })
-        c.Eblock('}')
 
     return c
 
   def _InitializePropertyToDefault(self, prop, dst):
     """Initialize a model.Property to its default value inside an object.
 
     dst: Type*
     """
     c = code.Code()
     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