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._GenerateCallbackCreate(
+          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._GenerateCallbackCreate(
+          "%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 286 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 _GenerateCallbackCreate(self, function_scope, callback):
+    """Generate function to create Value parameters for a callback.
 
     E.g for function "Bar", generate Bar::Result::Create
+    E.g for event "Gar", generate Gar::Create
     """
     c = Code()
-    params = function.callback.params
+    params = callback.params
 
     if not params:
-      (c.Append('Value* %s::Result::Create() {' % cpp_namespace)
+      (c.Append('Value* %s::Create() {' % function_scope)
         .Append('  return Value::CreateNullValue();')
         .Append('}')
       )
     else:
       expanded_params = self._cpp_type_generator.GetExpandedChoicesInParams(
           params)
-      c.Concat(self._GeneratePropertyFunctions(
-          cpp_namespace + '::Result', expanded_params))
+      c.Concat(self._GeneratePropertyFunctions(function_scope, 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
         # 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.Sblock('Value* %(function_scope)s::Create(const %(arg)s) {')
         c.Append('return %s;' %
            self._CreateValueFromProperty(param_copy, param_copy.unix_name))
         c.Eblock('}')
         c.Substitute({
-            'cpp_namespace': cpp_namespace,
+            'function_scope': function_scope,
             'arg': cpp_util.GetParameterDeclaration(
                 param_copy, self._cpp_type_generator.GetType(param_copy))
         })
 
     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;
@@ skipping 23 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)