Initial commit of the Dart Chrome Extension APIs generators

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, Type
 import cpp_util
 import schema_util
 
 class HGenerator(object):
+  def __init__(self, type_generator, cpp_namespace):
+    self._type_generator = type_generator
+    self._cpp_namespace = cpp_namespace
+
+  def Generate(self, namespace):
+    return _Generator(namespace,
+                      self._type_generator,
+                      self._cpp_namespace).Generate()
+
+class _Generator(object):
   """A .h generator for a namespace.
   """
-  def __init__(self, namespace, cpp_type_generator):
+  def __init__(self, namespace, cpp_type_generator, cpp_namespace):
+    self._namespace = namespace
     self._type_helper = cpp_type_generator
-    self._namespace = namespace
+    self._cpp_namespace = cpp_namespace
     self._target_namespace = (
         self._type_helper.GetCppNamespaceName(self._namespace))
 
   def Generate(self):
     """Generates a Code object with the .h for a single namespace.
     """
     c = Code()
     (c.Append(cpp_util.CHROMIUM_LICENSE)
       .Append()
       .Append(cpp_util.GENERATED_FILE_MESSAGE % self._namespace.source_file)
@@ skipping 11 matching lines @@
       .Append()
       .Append('#include "base/basictypes.h"')
       .Append('#include "base/logging.h"')
       .Append('#include "base/memory/linked_ptr.h"')
       .Append('#include "base/memory/scoped_ptr.h"')
       .Append('#include "base/values.h"')
       .Cblock(self._type_helper.GenerateIncludes())
       .Append()
     )
 
-    c.Concat(self._type_helper.GetRootNamespaceStart())
+    c.Concat(cpp_util.OpenNamespace(self._cpp_namespace))
     # TODO(calamity): These forward declarations should be #includes to allow
     # $ref types from other files to be used as required params. This requires
     # some detangling of windows and tabs which will currently lead to circular
     # #includes.
     forward_declarations = (
         self._type_helper.GenerateForwardDeclarations())
     if not forward_declarations.IsEmpty():
       (c.Append()
         .Cblock(forward_declarations)
       )
@@ skipping 31 matching lines @@
         c.Cblock(self._GenerateFunction(function))
     if self._namespace.events:
       (c.Append('//')
         .Append('// Events')
         .Append('//')
         .Append()
       )
       for event in self._namespace.events.values():
         c.Cblock(self._GenerateEvent(event))
     (c.Concat(self._type_helper.GetNamespaceEnd())
-      .Cblock(self._type_helper.GetRootNamespaceEnd())
+      .Concat(cpp_util.CloseNamespace(self._cpp_namespace))
       .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
     depended-upon types appear before types which depend on them.
     """
     dependency_order = []
@@ skipping 125 matching lines @@
         if type_.additional_properties.property_type == PropertyType.ANY:
           c.Append('base::DictionaryValue additional_properties;')
         else:
           (c.Cblock(self._GenerateType(type_.additional_properties))
             .Append('std::map<std::string, %s> additional_properties;' %
                 cpp_util.PadForGenerics(
                     self._type_helper.GetCppType(type_.additional_properties,
                                                  is_in_container=True)))
           )
       (c.Eblock()
+        .Append()
         .Sblock(' private:')
           .Append('DISALLOW_COPY_AND_ASSIGN(%(classname)s);')
         .Eblock('};')
       )
     elif type_.property_type == PropertyType.CHOICES:
       if type_.description:
         c.Comment(type_.description)
       # Choices are modelled with optional fields for each choice. Exactly one
       # field of the choice is guaranteed to be set by the compiler.
       (c.Sblock('struct %(classname)s {')
@@ skipping 58 matching lines @@
       return Code()
 
     c = Code()
     (c.Sblock('struct Params {')
       .Append('static scoped_ptr<Params> Create(const base::ListValue& args);')
       .Append('~Params();')
       .Append()
       .Cblock(self._GenerateTypes(p.type_ for p in function.params))
       .Cblock(self._GenerateFields(function.params))
       .Eblock()
+      .Append()
       .Sblock(' private:')
         .Append('Params();')
         .Append()
         .Append('DISALLOW_COPY_AND_ASSIGN(Params);')
       .Eblock('};')
     )
     return c
 
   def _GenerateTypes(self, types, is_toplevel=False, generate_typedefs=False):
     """Generate the structures required by a property such as OBJECT classes
@@ skipping 26 matching lines @@
   def _GenerateFunctionResults(self, callback):
     """Generates namespace for passing a function's result back.
     """
     c = Code()
     (c.Append('namespace Results {')
       .Append()
       .Concat(self._GenerateCreateCallbackArguments(callback))
       .Append('}  // namespace Results')
     )
     return c