JSON Schema Compiler: Added event compilation.

tools/json_schema_compiler/h_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 cpp_util
 import model
 import os
 import schema_util
@@ skipping 74 matching lines @@
     if self._namespace.functions:
       (c.Append('//')
         .Append('// Functions')
         .Append('//')
         .Append()
       )
       for function in self._namespace.functions.values():
         (c.Concat(self._GenerateFunction(function))
           .Append()
         )
+    if self._namespace.events:
+      (c.Append('//')
+        .Append('// Events')
+        .Append('//')
+        .Append()
+      )
+      for event in self._namespace.events.values():
+        (c.Concat(self._GenerateEvent(event))
+          .Append()
+        )
     (c.Concat(self._cpp_type_generator.GetNamespaceEnd())
       .Concat(self._cpp_type_generator.GetRootNamespaceEnd())
       .Append()
       .Append('#endif  // %s' % ifndef_name)
       .Append()
     )
     return c
 
   def _FieldDependencyOrder(self):
     """Generates the list of types in the current namespace in an order in which
@@ skipping 100 matching lines @@
         )
 
       (c.Eblock()
         .Sblock(' private:')
           .Append('DISALLOW_COPY_AND_ASSIGN(%(classname)s);')
         .Eblock('};')
       )
     c.Substitute({'classname': classname})
     return c
 
+  def _GenerateEvent(self, event):
+    """Generates the namespaces for an event.
+    """
+    c = Code()
+    c.Sblock('namespace %s {' % cpp_util.Classname(event.name))
+    c.Concat(self._GenerateFromClientFunction(event))
+    c.Eblock('};')
+    return c
+
   def _GenerateFunction(self, function):
-    """Generates the structs for a function.
+    """Generates the namespaces and structs for a function.
     """
     c = Code()
     (c.Sblock('namespace %s {' % cpp_util.Classname(function.name))
         .Concat(self._GenerateFunctionParams(function))
         .Append()
     )
     if function.callback:
-      (c.Concat(self._GenerateFunctionResult(function))
+      (c.Concat(self._GenerateFunctionResult(function.callback))
         .Append()
       )
     c.Eblock('};')
 
     return c
 
   def _GenerateFunctionParams(self, function):
-    """Generates the struct for passing parameters into a function.
+    """Generates the struct for passing parameters from JSON to a function.
     """
     c = Code()
 
     if function.params:
       (c.Sblock('struct Params {')
           .Concat(self._GeneratePropertyStructures(function.params))
           .Concat(self._GenerateFields(function.params))
           .Append('~Params();')
           .Append()
           .Append('static scoped_ptr<Params> Create(const ListValue& args);')
@@ skipping 24 matching lines @@
             self._cpp_type_generator.GetChoicesEnumType(prop),
             prop,
             [choice.type_.name for choice in prop.choices.values()]))
         c.Concat(self._GeneratePropertyStructures(prop.choices.values()))
       elif prop.type_ == PropertyType.ENUM:
         enum_name = self._cpp_type_generator.GetType(prop)
         c.Concat(self._GenerateEnumDeclaration(
             enum_name,
             prop,
             prop.enum_values))
-        c.Append('static scoped_ptr<Value> CreateEnumValue(%s %s);' %
-            (enum_name, prop.unix_name))
+        # If the property is from the UI then we're in a struct so this function
+        # should be static. If it's from the client, then we're just in a
+        # namespace so we can't have the static keyword.
+        if prop.from_json:

[Matt Tytel, 2012/06/29 23:06:40]

On alternative to this is to define this function here in the header file. Then
we could put in static either way.

[not at google - send to devlin, 2012/07/03 14:21:39]

Don't follow?

This approach is fine I think. I'd tweak the comment a bit though:

# If the property is "from_json" then we're generating populated structs for it.
# This means that the ::Create utility methods are inside that struct{} and
# need to be "static".
# If not, they're probably being generated inside a namespace{} block as a
# client utility, so "static" would be incorrect.

You'll need to make the same change in cc_generator, by the way. It prints "//
static" incorrectly under these circumstances.

[Matt Tytel, 2012/07/11 02:08:50]

If we define CreateEnumValue here in the header file instead of in the cc file,
then we can make it static regardless if we are in a class or a namespace. Trade
off is we have less logic in the json_schema_compiler but worse style

+          c.Append('static scoped_ptr<Value> CreateEnumValue(%s %s);' %
+              (enum_name, prop.unix_name))
+        else:
+          c.Append('scoped_ptr<Value> CreateEnumValue(%s %s);' %
+              (enum_name, prop.unix_name))

[not at google - send to devlin, 2012/07/03 14:21:39]

Clean this up a bit:

create_enum_value = 'scoped_ptr<Value> CreateEnumValue(%s %s);' %
                     (enum_name, prop.unix_name)

# comment.
if prop.from_json:
  create_enum_value = 'static ' + create_enum_value
return c.Append(create_enum_value)

[Matt Tytel, 2012/07/11 02:08:50]

Done.

     return c
 
-  def _GenerateFunctionResult(self, function):
-    """Generates functions for passing a function's result back.
+  def _GenerateFromClientFunction(self, function):

[not at google - send to devlin, 2012/07/03 14:21:39]

Same comments in here as in cc_generator.

Also: call this function GenerateCreateCallbackArguments like in there?

[Matt Tytel, 2012/07/11 02:08:50]

Done.

+    """Generates functions for passing paramaters to a callback.
     """
     c = Code()
-
-    c.Sblock('namespace Result {')
-    params = function.callback.params
+    params = function.params
     if not params:
       c.Append('Value* Create();')
     else:
       c.Concat(self._GeneratePropertyStructures(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 self._cpp_type_generator.GetExpandedChoicesInParams(params):
         if param.description:
           c.Comment(param.description)
         if param.type_ == PropertyType.ANY:
-          c.Comment("Value* Result::Create(Value*) not generated "
+          c.Comment("Value* Create(Value*) not generated "
                     "because it's redundant.")
           continue
         c.Append('Value* Create(const %s);' % cpp_util.GetParameterDeclaration(
             param, self._cpp_type_generator.GetType(param)))
+
+    return c
+
+  def _GenerateFunctionResult(self, callback):
+    """Generates namespace for passing a function's result back.
+    """
+    c = Code()
+    c.Sblock('namespace Result {')
+    c.Concat(self._GenerateFromClientFunction(callback))
     c.Eblock('};')
 
     return c