JSON Schema Compiler: Added event compilation.

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 68 matching lines @@
       (c.Append('//')
         .Append('// Functions')
         .Append('//')
         .Append()
       )
     for function in self._namespace.functions.values():
       (c.Concat(self._GenerateFunction(
           cpp_util.Classname(function.name), function))
         .Append()
       )
+    if self._namespace.events:
+      (c.Append('//')
+        .Append('// Events')
+        .Append('//')
+        .Append()
+      )
+    for event in self._namespace.events.values():
+      (c.Concat(self._GenerateCreateCallbackArguments(
+          cpp_util.Classname(event.name), event))
+        .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_):
     """Generates the function definitions for a type.
     """
     classname = cpp_util.Classname(schema_util.StripSchemaNamespace(type_.name))
     c = Code()
 
     if type_.functions:
       for function in type_.functions.values():
@@ skipping 169 matching lines @@
           function.params))
       (c.Append('%(cpp_namespace)s::Params::Params() {}')
         .Append('%(cpp_namespace)s::Params::~Params() {}')
         .Append()
         .Concat(self._GenerateFunctionParamsCreate(cpp_namespace, function))
         .Append()
       )
 
     # Result::Create function
     if function.callback:
-      c.Concat(self._GenerateFunctionResultCreate(cpp_namespace, function))
+      c.Concat(self._GenerateCreateCallbackArguments(
+          "%s::Result" % cpp_namespace, function.callback))
 
     c.Substitute({'cpp_namespace': cpp_namespace})
 
     return c
 
   def _GenerateCreateEnumValue(self, cpp_namespace, prop):
     """Generates CreateEnumValue() that returns the |StringValue|
     representation of an enum.
     """
     c = Code()
@@ skipping 209 matching lines @@
         self._GenerateListValueToEnumArrayConversion(c, prop)
       else:
         (c.Append('if (!%s)' % self._util_cc_helper.PopulateArrayFromList(
               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]):
+      for choice in self._cpp_type_generator.GetAllPossibleParameters([prop]):
         (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('}')
@@ skipping 92 matching lines @@
         c.Concat(self._GeneratePropertyFunctions(
             param_namespace, [param.item_type]))
       elif param.type_ == PropertyType.CHOICES:
         c.Concat(self._GeneratePropertyFunctions(
             param_namespace, param.choices.values()))
       elif param.type_ == PropertyType.ENUM:
         c.Concat(self._GenerateCreateEnumValue(param_namespace, param))
         c.Append()
     return c
 
-  def _GenerateFunctionResultCreate(self, cpp_namespace, function):
-    """Generate function to create a Result given the return value.
+  def _GenerateCreateCallbackArguments(self, function_scope, callback):
+    """Generate all functions to create Value parameters for a callback.
 
     E.g for function "Bar", generate Bar::Result::Create
+    E.g for event "Baz", generate Baz::Create
+
+    function_scope: the function scope path, e.g. Foo::Bar for the function
+    Foo::Bar::Baz().
+    callback: the Function object we are creating callback arguments for.
     """
     c = Code()
-    params = function.callback.params
+    params = callback.params
+    all_params = self._cpp_type_generator.GetAllPossibleParameters(params)
+    c.Concat(self._GeneratePropertyFunctions(function_scope, all_params))
 
-    if not params:
-      (c.Append('Value* %s::Result::Create() {' % cpp_namespace)
-        .Append('  return Value::CreateNullValue();')
-        .Append('}')
-      )
-    else:
-      expanded_params = self._cpp_type_generator.GetExpandedChoicesInParams(
-          params)
-      c.Concat(self._GeneratePropertyFunctions(
-          cpp_namespace + '::Result', expanded_params))
-
-      # 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 expanded_params:
-        if param.type_ == PropertyType.ANY:
-          # Generation of Value* Create(Value*) is redundant.
-          continue
+    param_lists = self._cpp_type_generator.GetAllPossibleParameterLists(params)
+    for param_list in param_lists:
+      c.Sblock('ListValue* %(function_scope)s::Create(%(declaration_list)s) {')

[not at google - send to devlin, 2012/07/11 07:22:06]

return a scoped_ptr<ListValue> rather than a ListValue*?

[Matt Tytel, 2012/07/12 03:07:56]

This CL is getting a bit heavy. Can I do this separate?

[not at google - send to devlin, 2012/07/12 03:36:49]

sounds good.

[Matt Tytel, 2012/07/13 02:34:43]

Zoop. Might as well do it in this CL since I changed the return type and I'll
have to change a bunch of files because of it anyway.

[not at google - send to devlin, 2012/07/13 02:40:32]

Cool sg

+      c.Append('ListValue* create_results = new 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
-        c.Sblock('Value* %(cpp_namespace)s::Result::Create(const %(arg)s) {')
-        c.Append('return %s;' %
-           self._CreateValueFromProperty(param_copy, param_copy.unix_name))
-        c.Eblock('}')
-        c.Substitute({
-            'cpp_namespace': cpp_namespace,
-            'arg': cpp_util.GetParameterDeclaration(
-                param_copy, self._cpp_type_generator.GetType(param_copy))
-        })
+        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)))
+
+      c.Append('return create_results;')

[not at google - send to devlin, 2012/07/11 07:22:06]

.Pass()

+      c.Eblock('}')
+      c.Substitute({
+          'function_scope': function_scope,
+          'declaration_list': '%s' % ', '.join(declaration_list)

[not at google - send to devlin, 2012/07/11 07:22:06]

Is this some kind of Python idiom/requirement I'm not aware of, or is the '%s' %
unnecessary and that can be just ', '.join(declaration_list) ?

[Matt Tytel, 2012/07/12 03:07:56]

... % '%s' % '%s' % '%s' % ', '.join(declaration_list).
(Done.)

+      })
 
     return c
 
   def _InitializePropertyToDefault(self, prop, dst):
     """Initialize a model.Property to its default value inside an object.
 
     E.g for optional enum "state", generate dst->state = STATE_NONE;
 
     dst: Type*
     """
@@ skipping 20 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)