Java: Implements union generation.

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 ast
 import contextlib
 import os
@@ skipping 328 matching lines @@
 def GetArrayExpectedLength(kind):
   if mojom.IsArrayKind(kind) and kind.length is not None:
     return getattr(kind, 'java_map_size', str(kind.length))
   else:
     return 'org.chromium.mojo.bindings.BindingsHelper.UNSPECIFIED_ARRAY_LENGTH'
 
 def IsPointerArrayKind(kind):
   if not mojom.IsArrayKind(kind):
     return False
   sub_kind = kind.kind
-  return mojom.IsObjectKind(sub_kind)
+  return mojom.IsObjectKind(sub_kind) and not mojom.IsUnionKind(sub_kind)
+
+def IsUnionArrayKind(kind):
+  if not mojom.IsArrayKind(kind):
+    return False
+  sub_kind = kind.kind
+  return mojom.IsUnionKind(sub_kind)
 
 def GetConstantsMainEntityName(module):
   if module.attributes and 'JavaConstantsClassName' in module.attributes:
     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')
 
 def GetMethodOrdinalName(method):
@@ skipping 41 matching lines @@
     'has_method_with_response': HasMethodWithResponse,
     'interface_response_name': GetInterfaceResponseName,
     'is_array_kind': mojom.IsArrayKind,
     'is_any_handle_kind': mojom.IsAnyHandleKind,
     'is_interface_request_kind': mojom.IsInterfaceRequestKind,
     'is_map_kind': mojom.IsMapKind,
     'is_nullable_kind': mojom.IsNullableKind,
     'is_pointer_array_kind': IsPointerArrayKind,
     'is_reference_kind': mojom.IsReferenceKind,
     'is_struct_kind': mojom.IsStructKind,
+    'is_union_array_kind': IsUnionArrayKind,
     'is_union_kind': mojom.IsUnionKind,
     'java_true_false': GetJavaTrueFalse,
     'java_type': GetJavaType,
     'method_ordinal_name': GetMethodOrdinalName,
     'name': GetNameForElement,
     'new_array': NewArray,
+    'ucc': lambda x: UpperCamelCase(x.name),
   }
 
   def GetJinjaExports(self):
     return {
       'package': GetPackage(self.module),
     }
 
   def GetJinjaExportsForInterface(self, interface):
     exports = self.GetJinjaExports()
     exports.update({'interface': interface})
     return exports
 
   @UseJinja('java_templates/enum.java.tmpl', filters=java_filters)
   def GenerateEnumSource(self, enum):
     exports = self.GetJinjaExports()
     exports.update({'enum': enum})
     return exports
 
   @UseJinja('java_templates/struct.java.tmpl', filters=java_filters)
   def GenerateStructSource(self, struct):
     exports = self.GetJinjaExports()
     exports.update({'struct': struct})
     return exports
 
+  @UseJinja('java_templates/union.java.tmpl', filters=java_filters)
+  def GenerateUnionSource(self, union):
+    exports = self.GetJinjaExports()
+    exports.update({'union': union})
+    return exports
+
   @UseJinja('java_templates/interface.java.tmpl', filters=java_filters)
   def GenerateInterfaceSource(self, interface):
     return self.GetJinjaExportsForInterface(interface)
 
   @UseJinja('java_templates/interface_internal.java.tmpl', filters=java_filters)
   def GenerateInterfaceInternalSource(self, interface):
     return self.GetJinjaExportsForInterface(interface)
 
   @UseJinja('java_templates/constants.java.tmpl', filters=java_filters)
   def GenerateConstantsSource(self, module):
     exports = self.GetJinjaExports()
     exports.update({'main_entity': GetConstantsMainEntityName(module),
                     'constants': module.constants})
     return exports
 
   def DoGenerateFiles(self):
     fileutil.EnsureDirectoryExists(self.output_dir)
 
     # Keep this above the others as .GetStructs() changes the state of the
     # module, annotating structs with required information.
     for struct in self.GetStructs():
       self.Write(self.GenerateStructSource(struct),
                  '%s.java' % GetNameForElement(struct))
 
+    for union in self.module.unions:
+      self.Write(self.GenerateUnionSource(union),
+                 '%s.java' % GetNameForElement(union))
+
     for enum in self.module.enums:
       self.Write(self.GenerateEnumSource(enum),
                  '%s.java' % GetNameForElement(enum))
 
     for interface in self.GetInterfaces():
       self.Write(self.GenerateInterfaceSource(interface),
                  '%s.java' % GetNameForElement(interface))
       self.Write(self.GenerateInterfaceInternalSource(interface),
                  '%s_Internal.java' % GetNameForElement(interface))
 
@@ skipping 25 matching lines @@
     return {
       'lstrip_blocks': True,
       'trim_blocks': True,
     }
 
   def GetGlobals(self):
     return {
       'namespace': self.module.namespace,
       'module': self.module,
     }