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 62 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 @@
     if function.params:
       c.Concat(self._GeneratePropertyFunctions(cpp_namespace + '::Params',
           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
+    # Results::Create function
     if function.callback:
-      c.Concat(self._GenerateFunctionResultCreate(cpp_namespace, function))
+      c.Concat(self._GenerateCreateCallbackArguments(
+          "%s::Results" % cpp_namespace, function.callback))
 
     c.Substitute({'cpp_namespace': cpp_namespace})
 
     return c
 
   def _GenerateCreateEnumValue(self, cpp_namespace, prop):
     """Generates CreateEnumValue() that returns the |base::StringValue|
     representation of an enum.
     """
     c = Code()
@@ skipping 212 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.ExpandParams([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 73 matching lines @@
           '(enum_as_string == "%s")' % enum_value)
         .Append('  ' + enum_temp + ' = %s;' % (
           self._cpp_type_generator.GetEnumValue(prop, enum_value)))
       )
     (c.Append('else')
       .Append('  return %(failure_value)s;')
     )
 
   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.
+    CreateEnumValue for ENUMs and Populate/ToValue for Params/Results objects.
     """
     c = Code()
     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.ARRAY:
         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 function "Bar", generate Bar::Results::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
+    expanded_params = self._cpp_type_generator.ExpandParams(params)
+    c.Concat(self._GeneratePropertyFunctions(function_scope, expanded_params))
 
-    if not params:
-      (c.Append('base::Value* %s::Result::Create() {' % cpp_namespace)
-        .Append('  return base::Value::CreateNullValue();')
-        .Append('}')
+    param_lists = self._cpp_type_generator.GetAllPossibleParameterLists(params)
+    for param_list in param_lists:
+      (c.Sblock('scoped_ptr<base::ListValue> %(function_scope)s::'
+                'Create(%(declaration_list)s) {')
+        .Append('scoped_ptr<base::ListValue> create_results('
+                'new base::ListValue());')
       )
-    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 base::Value* Create(base::Value*) is redundant.
-          continue
+      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('base::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.Pass();')
+      c.Eblock('}')
+      c.Substitute({
+          'function_scope': function_scope,
+          'declaration_list': ', '.join(declaration_list)
+      })
 
     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)