Generate java bindings for structs.

mojo/public/tools/bindings/generators/mojom_java_generator.py

 # Copyright 2014 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.
 
 """Generates java source files from a mojom.Module."""
 
 import argparse
 import os
 import re
 
 import mojom.generate.generator as generator
 import mojom.generate.module as mojom
+import mojom.generate.pack as pack

[rmcilroy, 2014/06/05 11:01:17]

nit - remove unneeded import.

[qsr, 2014/06/05 11:46:11]

Done.

 from mojom.generate.template_expander import UseJinja
 
 
 GENERATOR_PREFIX = 'java'
 
 _spec_to_java_type = {
   'b':     'boolean',
   'd':     'double',
   'f':     'float',
   'h:d:c': 'org.chromium.mojo.system.DataPipe.ConsumerHandle',
@@ skipping 32 matching lines @@
   uccc = UpperCamelCase(name)
   return uccc[0].lower() + uccc[1:]
 
 def ConstantStyle(name):
   components = NameToComponent(name)
   if components[0] == 'k':
     components = components[1:]
   return '_'.join([x.upper() for x in components])
 
 def GetNameForElement(element):
-  if (isinstance(element, mojom.Enum) or
-      isinstance(element, mojom.Interface) or
-      isinstance(element, mojom.Struct)):
+  if isinstance(element, (mojom.Enum,
+                          mojom.Interface,
+                          mojom.Struct)):
     return UpperCamelCase(element.name)
-  if (isinstance(element, mojom.Method) or
-      isinstance(element, mojom.Parameter) or
-      isinstance(element, mojom.Field)):
+  if isinstance(element, mojom.InterfaceRequest):
+    return GetNameForElement(element.kind)
+  if isinstance(element, (mojom.Method,
+                          mojom.Parameter,
+                          mojom.Field)):
     return CamelCase(element.name)
   if isinstance(element,  mojom.EnumValue):
     return (UpperCamelCase(element.enum_name) + '.' +
             ConstantStyle(element.name))
-  if (isinstance(element, mojom.NamedValue) or
-      isinstance(element, mojom.Constant)):
+  if isinstance(element, (mojom.NamedValue,
+                          mojom.Constant)):
     return ConstantStyle(element.name)
   raise Exception("Unexpected element: " % element)
 
 def ParseStringAttribute(attribute):
   if isinstance(attribute, basestring):
     return attribute
   assert attribute[0] == 'EXPRESSION'
   assert len(attribute[1]) == 1
   return attribute[1][0][1:-1].encode('string_escape')
 
 def GetPackage(module):
   if 'JavaPackage' in module.attributes:
     return ParseStringAttribute(module.attributes['JavaPackage'])
   # Default package.
   return "org.chromium.mojom." + module.namespace
 
+def GetSuperClass(method):
+  return "org.chromium.mojo.bindings.Struct"
+
 def GetNameForKind(kind):
   def _GetNameHierachy(kind):
     hierachy = []
     if kind.parent_kind:
       hierachy = _GetNameHierachy(kind.parent_kind)
-    hierachy.append(kind.name)
+    hierachy.append(GetNameForElement(kind))
     return hierachy
 
   elements = [GetPackage(kind.module)]
   elements += _GetNameHierachy(kind)
   return '.'.join(elements)
 
 def GetJavaType(kind):
   if isinstance(kind, (mojom.Struct, mojom.Interface)):
     return GetNameForKind(kind)
+  if isinstance(kind, mojom.InterfaceRequest):
+    return GetNameForKind(kind.kind)
   if isinstance(kind, mojom.Array):
     return "%s[]" % GetJavaType(kind.kind)
   if isinstance(kind, mojom.Enum):
     return "int"
   return _spec_to_java_type[kind.spec]
 
+def IsHandle(kind):
+  return kind.spec[0] == 'h'
+
 def TranslateConstants(token, module):
   def _TranslateNamedValue(named_value):
     entity_name = GetNameForElement(named_value)
     if named_value.parent_kind:
       return GetJavaType(named_value.parent_kind) + '.' + entity_name
     # Handle the case where named_value is a module level constant:
     if not isinstance(named_value, mojom.EnumValue):
       entity_name = (GetConstantsMainEntityName(named_value.module) + '.' +
                       entity_name)
     return GetPackage(named_value.module) + '.' + entity_name
@@ skipping 16 matching lines @@
     return ParseStringAttribute(module.attributes['JavaConstantsClassName'])
   # This constructs the name of the embedding classes for module level constants
   # by extracting the mojom's filename and prepending it to Constants.
   return (UpperCamelCase(module.path.split('/')[-1].rsplit('.', 1)[0]) +
           'Constants')
 
 class Generator(generator.Generator):
 
   java_filters = {
     "expression_to_text": ExpressionToText,
+    "is_handle": IsHandle,
     "java_type": GetJavaType,
     "name": GetNameForElement,
+    "super_class": GetSuperClass,
     "verify_token_type": generator.VerifyTokenType,
   }
 
   def GetJinjaExports(self):
     return {
       "module": self.module,
       "package": GetPackage(self.module),
     }
 
+  @UseJinja("java_templates/enum.java.tmpl", filters=java_filters,
+            lstrip_blocks=True, trim_blocks=True)
+  def GenerateEnumSource(self, enum):
+    exports = self.GetJinjaExports()
+    exports.update({"enum": enum})
+    return exports
+
+  @UseJinja("java_templates/struct.java.tmpl", filters=java_filters,
+            lstrip_blocks=True, trim_blocks=True)
+  def GenerateStructSource(self, struct):
+    exports = self.GetJinjaExports()
+    exports.update({"struct": struct})
+    return exports
+
   @UseJinja("java_templates/constants.java.tmpl", filters=java_filters,
             lstrip_blocks=True, trim_blocks=True)
   def GenerateConstantsSource(self, module):
     exports = self.GetJinjaExports()
     exports.update({"main_entity": GetConstantsMainEntityName(module),
                     "constants": module.constants})
     return exports
 
   def GenerateFiles(self, unparsed_args):
     parser = argparse.ArgumentParser()
     parser.add_argument("--java_output_directory", dest="java_output_directory")
     args = parser.parse_args(unparsed_args)
     if self.output_dir and args.java_output_directory:
       self.output_dir = os.path.join(args.java_output_directory,
                                      GetPackage(self.module).replace('.', '/'))
       if not os.path.exists(self.output_dir):
         try:
           os.makedirs(self.output_dir)
         except:
           # Ignore errors on directory creation.
           pass
 
+    for enum in self.module.enums:
+      self.Write(self.GenerateEnumSource(enum),
+                 "%s.java" % GetNameForElement(enum))
+
+    for struct in self.module.structs:
+      self.Write(self.GenerateStructSource(struct),
+                 "%s.java" % GetNameForElement(struct))
+
     if self.module.constants:
       self.Write(self.GenerateConstantsSource(self.module),
                  "%s.java" % GetConstantsMainEntityName(self.module))