Initial commit of the Dart Chrome Extension APIs generators

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, Type
 import cpp_util
 import model
 import schema_util
 import sys
 import util_cc_helper
 
 class CCGenerator(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 .cc 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))
     self._util_cc_helper = (
         util_cc_helper.UtilCCHelper(self._type_helper))
 
   def Generate(self):
     """Generates a Code object with the .cc for a single namespace.
     """
     c = Code()
     (c.Append(cpp_util.CHROMIUM_LICENSE)
       .Append()
       .Append(cpp_util.GENERATED_FILE_MESSAGE % self._namespace.source_file)
       .Append()
       .Append(self._util_cc_helper.GetIncludePath())
       .Append('#include "base/json/json_writer.h"')
       .Append('#include "base/logging.h"')
       .Append('#include "base/string_number_conversions.h"')
       .Append('#include "%s/%s.h"' %
           (self._namespace.source_file_dir, self._namespace.unix_name))
       .Cblock(self._type_helper.GenerateIncludes(include_soft=True))
-      .Concat(self._type_helper.GetRootNamespaceStart())
+      .Concat(cpp_util.OpenNamespace(self._cpp_namespace))
       .Cblock(self._type_helper.GetNamespaceStart())
     )
     if self._namespace.properties:
       (c.Append('//')
         .Append('// Properties')
         .Append('//')
         .Append()
       )
       for property in self._namespace.properties.values():
         property_code = self._type_helper.GeneratePropertyValues(
@@ skipping 19 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())
+      .Cblock(cpp_util.CloseNamespace(self._cpp_namespace))
     )
     return c
 
   def _GenerateType(self, cpp_namespace, type_):
     """Generates the function definitions for a type.
     """
     classname = cpp_util.Classname(schema_util.StripNamespace(type_.name))
     c = Code()
 
     if type_.functions:
@@ skipping 712 matching lines @@
     """
     c = Code()
     underlying_type = self._type_helper.FollowRef(prop.type_)
     if (underlying_type.property_type == PropertyType.ENUM and
         prop.optional):
       c.Append('%s->%s = %s;' % (
         dst,
         prop.unix_name,
         self._type_helper.GetEnumNoneValue(prop.type_)))
     return c