Supporting more APIs with json_schema_compiler

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 model import PropertyType
 import code
 import cpp_util
 import os
 
 class HGenerator(object):
@@ skipping 17 matching lines @@
 
     ifndef_name = self._GenerateIfndefName()
     (c.Append('#ifndef %s' % ifndef_name)
       .Append('#define %s' % ifndef_name)
       .Append('#pragma once')
       .Append()
       .Append('#include <string>')
       .Append('#include <vector>')
       .Append()
       .Append('#include "base/basictypes.h"')
+      .Append('#include "base/memory/linked_ptr.h"')
       .Append('#include "base/memory/scoped_ptr.h"')
       .Append('#include "base/values.h"')
       .Append()
-      .Append('using base::Value;')
-      .Append('using base::DictionaryValue;')
-      .Append('using base::ListValue;')
-      .Append()
     )
 
-    includes = self._cpp_type_generator.GenerateCppIncludes()
-    if not includes.IsEmpty():
-      (c.Concat(includes)
+    c.Concat(self._cpp_type_generator.GetRootNamespaceStart())
+    forward_declarations = (
+        self._cpp_type_generator.GenerateForwardDeclarations())
+    if not forward_declarations.IsEmpty():
+      (c.Append()
+        .Concat(forward_declarations)
         .Append()
       )
 
-    (c.Concat(self._cpp_type_generator.GetCppNamespaceStart())
+    (c.Concat(self._cpp_type_generator.GetNamespaceStart())
       .Append()
       .Append('//')
       .Append('// Types')
       .Append('//')
       .Append()
     )
     for type_ in self._namespace.types.values():
       (c.Concat(self._GenerateType(type_))
         .Append()
       )
     (c.Append('//')
       .Append('// Functions')
       .Append('//')
       .Append()
     )
     for function in self._namespace.functions.values():
       (c.Concat(self._GenerateFunction(function))
         .Append()
       )
     (c.Append()
-      .Append()
-      .Concat(self._cpp_type_generator.GetCppNamespaceEnd())
+      .Concat(self._cpp_type_generator.GetNamespaceEnd())
+      .Concat(self._cpp_type_generator.GetRootNamespaceEnd())
       .Append()
       .Append('#endif  // %s' % ifndef_name)
       .Append()
     )
     return c
 
+  def _GenerateFields(self, props):
+    """Generates the field declarations when declaring a type.
+    """
+    c = code.Code()
+    for prop in self._cpp_type_generator.GetExpandedChoicesInParams(props):
+      if prop.description:
+        c.Comment(prop.description)
+      c.Append('%s %s;' % (
+          self._cpp_type_generator.GetType(prop, wrap_optional=True),
+          prop.unix_name))
+      c.Append()
+    # Generate the enums needed for any fields with "choices"
+    for prop in [x for x in props if x.type_ == PropertyType.CHOICES]:

[Yoyo Zhou, 2012/02/10 01:49:33]

Why not just
for prop in props:
  if prop.type__ == ...:

[calamity, 2012/02/10 03:52:50]

Hah, that's what is was before. I thought it'd be more python-y to use a list
comprehension. Reverted.

[Yoyo Zhou, 2012/02/10 19:43:21]

It is more python-y if it becomes less code, but in this case you're just
iterating over the values, not making a list.

+      enum_name = self._cpp_type_generator.GetChoicesEnumType(prop)
+      c.Sblock('enum %s {' % enum_name)
+      c.Append(self._cpp_type_generator.GetChoiceEnumNoneValue(prop) + ',')
+      for choice in prop.choices.values():
+        c.Append(self._cpp_type_generator.GetChoiceEnumValue(prop, choice.type_)
+            + ',')
+      (c.Eblock('};')
+        .Append()
+        .Append('%s %s_type;' % (enum_name, prop.unix_name))
+      )
+    return c
+
   def _GenerateType(self, type_, serializable=True):
     """Generates a struct for a type.
     """
-    classname = cpp_util.CppName(type_.name)
+    classname = cpp_util.Classname(type_.name)
     c = code.Code()
     if type_.description:
       c.Comment(type_.description)
     (c.Sblock('struct %(classname)s {')
         .Append('~%(classname)s();')
         .Append('%(classname)s();')
         .Append()
-    )
-
-    for prop in type_.properties.values():
-      if prop.description:
-        c.Comment(prop.description)
-      if prop.optional:
-        c.Append('scoped_ptr<%s> %s;' %
-            (self._cpp_type_generator.GetType(prop, pad_for_generics=True),
-            prop.name))
-      else:
-        c.Append('%s %s;' %
-            (self._cpp_type_generator.GetType(prop), prop.name))
-      c.Append()
-
-    (c.Comment('Populates a %(classname)s object from a Value. Returns'
-               ' whether |out| was successfully populated.')
-      .Append('static bool Populate(const Value& value, %(classname)s* out);')
-      .Append()
+        .Concat(self._GenerateFields(type_.properties.values()))
+        .Comment('Populates a %(classname)s object from a Value. Returns'
+                 ' whether |out| was successfully populated.')
+        .Append('static bool Populate(const Value& value, %(classname)s* out);')
+        .Append()
     )
 
     if serializable:
       (c.Comment('Returns a new DictionaryValue representing the'
-                 ' serialized form of this %(classname)s object. Passes'
+                 ' serialized form of this %(classname)s object. Passes '
                  'ownership to caller.')
-        .Append('DictionaryValue* ToValue() const;')
+        .Append('scoped_ptr<DictionaryValue> ToValue() const;')
       )
     (c.Eblock()
     .Sblock(' private:')
       .Append('DISALLOW_COPY_AND_ASSIGN(%(classname)s);')
     .Eblock('};')
     )
     c.Substitute({'classname': classname})
     return c
 
   def _GenerateFunction(self, function):
     """Generates the structs for a function.
     """
     c = code.Code()
-    (c.Sblock('namespace %s {' % cpp_util.CppName(function.name))
+    (c.Sblock('namespace %s {' % cpp_util.Classname(function.name))
         .Concat(self._GenerateFunctionParams(function))
         .Append()
         .Concat(self._GenerateFunctionResult(function))
         .Append()
       .Eblock('};')
     )
     return c
 
   def _GenerateFunctionParams(self, function):
     """Generates the struct for passing parameters into a function.
     """
     c = code.Code()
 
     if function.params:
       c.Sblock('struct Params {')
       for param in function.params:
-        if param.description:
-          c.Comment(param.description)
         if param.type_ == PropertyType.OBJECT:
           c.Concat(self._GenerateType(param, serializable=False))
           c.Append()
-      for param in function.params:
-        c.Append('%s %s;' %
-            (self._cpp_type_generator.GetType(param), param.name))
-
-      (c.Append()
+      (c.Concat(self._GenerateFields(function.params))
         .Append('~Params();')
         .Append()
         .Append('static scoped_ptr<Params> Create(const ListValue& args);')
       .Eblock()
       .Sblock(' private:')
         .Append('Params();')
         .Append()
         .Append('DISALLOW_COPY_AND_ASSIGN(Params);')
+      .Eblock('};')
       )
 
-      c.Eblock('};')
-
     return c
 
   def _GenerateFunctionResult(self, function):
-    """Generates the struct for passing a function's result back.
+    """Generates functions for passing a function's result back.
     """
-    # TODO(calamity): Handle returning an object
     c = code.Code()
 
-    param = function.callback.param
-    # TODO(calamity): Put this description comment in less stupid place
-    if param.description:
-      c.Comment(param.description)
-    (c.Append('class Result {')
-      .Sblock(' public:')
-    )
-    arg = ''
-    # TODO(calamity): handle object
-    if param:
-      if param.type_ == PropertyType.REF:
-        arg =  'const %(type)s& %(name)s'
-      else:
+    c.Sblock('namespace Result {')
+    params = function.callback.params
+    if not params:
+      c.Append('Value* Create();')
+    else:
+      # 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):
         arg = 'const %(type)s %(name)s'
-      arg = arg % {
-          'type': self._cpp_type_generator.GetType(param),
-          'name': param.name
-      }
-    (c.Append('static Value* Create(%s);' % arg)
-    .Eblock()
-    .Sblock(' private:')
-      .Append('Result() {};')
-      .Append('DISALLOW_COPY_AND_ASSIGN(Result);')
-    .Eblock('};')
-    )
+        if param.type_ == PropertyType.REF:
+          arg =  'const %(type)s& %(name)s'
+        arg %= {
+          'type': self._cpp_type_generator.GetType(param, wrap_optional=True),
+          'name': param.unix_name,
+        }
+        if param.description:
+          c.Comment(param.description)
+        c.Append('Value* Create(%s);' % arg)
+    c.Eblock('};')
 
     return c
 
   def _GenerateIfndefName(self):
     """Formats a path and filename as a #define name.
 
     e.g chrome/extensions/gen, file.h becomes CHROME_EXTENSIONS_GEN_FILE_H__.
     """
     return (('%s_%s_H__' %
         (self._namespace.source_file_dir, self._target_namespace))
         .upper().replace(os.sep, '_'))