Implement python mojo bindings unions.

mojo/public/python/mojo_bindings/serialization.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.
 
 """Utility classes for serialization"""
 
 import struct
 
 
 # Format of a header for a struct or an array.
@@ skipping 200 matching lines @@
     needed_padding = NeededPaddingForAlignment(index, group.GetAlignment())
     if needed_padding:
       codes.append('x' * needed_padding)
       index = index + needed_padding
     codes.append(code)
     index = index + group.GetByteSize()
   alignment_needed = NeededPaddingForAlignment(index)
   if alignment_needed:
     codes.append('x' * alignment_needed)
   return struct.Struct(''.join(codes))
+
+
+class UnionSerializer(object):
+  """
+  Helper class to serialize/deserialize a union.
+  """
+  def __init__(self, fields):
+    self._fields = {field.index: field for field in fields}
+
+  def SerializeInline(self, union, handle_offset):
+    data = bytearray()
+    field = self._fields[union.tag]
+
+    (entry, handles) = field.field_type.Serialize(
+        union.data, 8, data, handle_offset)
+
+    if hasattr(field.field_type, 'union_type'):

[qsr, 2015/07/16 09:35:26]

I really don't like this.

Each time I see a CL for union, it is always a lot of exception/corner case etc.

The more I see it, the more I think we should not have inline serialization for
unions. We should always use a pointer. This would make the whole serialization
simpler.

Anyway, you should use isinstance(field.field_type, UnionType) if you want to
check type, and not the presence of a given field.

[azani, 2015/07/16 21:57:38]

I can certainly see your point, but that would also incur an extra 50% space
overhead per union.
UnionType is defined in descriptor.py and descriptor.py imports
serialization.py. This makes it difficult to get a reference to UnionType.

I could do something like this:

def GetUnionType(self):
  if self._union_type:
    return self._union_type
  from mojo_bindings import descriptor
  self._union_type = descriptor.UnionType
  return self._union_type

That has its own bad smell (importing within a function) but I'm happy to defer
on which option is better.

[qsr, 2015/07/17 10:53:58]

 Well, first of all this is a 8 bytes overhead at worst, which is again a 50%
overhead at worst. It is 0 overhead if the content is an union. And if the
content is a struct or an array, the percentage overhead is way lower than that
because you need to consider the content of the struct or array that is pointed
to.
 In the end, I do not think such a small gain is worst the code complexity which
makes it very hard to have correct encoding/decoding and also significantly
raises the bar to write bindings for a new language.

+      nested_union = bytearray(16)
+      HEADER_STRUCT.pack_into(nested_union, 0, entry[0], entry[1])
+      struct.pack_into('<Q', nested_union, 8, entry[2])

[qsr, 2015/07/16 09:35:25]

You should have a constant for this struct -> you do not want to recompute it
all the time.

[azani, 2015/07/16 21:57:39]

Done.

+
+      data = nested_union + data
+      entry = 8
+
+    return (16, union.tag, entry, data), handles
+
+  def Serialize(self, union, handle_offset):
+    (size, tag, entry, extra_data), handles = self.SerializeInline(
+        union, handle_offset)
+    data = bytearray(16)
+    data.extend(extra_data)
+
+    field = self._fields[union.tag]
+
+    HEADER_STRUCT.pack_into(data, 0, size, tag)
+    typecode = field.GetTypeCode()
+    if hasattr(field.field_type, 'union_type'):
+      typecode = 'Q'
+
+    struct.pack_into('<%s' % typecode, data, 8, entry)
+    return data, handles
+
+  def Deserialize(self, context, union_class):
+    if len(context.data) < HEADER_STRUCT.size:
+      raise DeserializationException(
+          'Available data too short to contain header.')
+    (size, tag) = HEADER_STRUCT.unpack_from(context.data)
+    if size == 0:
+      return None
+
+    if size != 16:
+      raise DeserializationException('Invalid union size %s' % size)
+
+    field = self._fields[tag]
+    if hasattr(field.field_type, 'union_type'):
+      ptr = struct.unpack_from('<Q', context.data, 8)[0]
+      value = field.field_type.Deserialize(ptr, context.GetSubContext(ptr+8))
+    else:
+      raw_value = struct.unpack_from(
+          field.GetTypeCode(), context.data, 8)[0]
+      value = field.field_type.Deserialize(raw_value, context.GetSubContext(8))
+
+    union = union_class.__new__(union_class)
+    union._tag = tag
+    union._data = value
+    return union