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.
+# Format of a header for a struct, array or union.
 HEADER_STRUCT = struct.Struct("<II")
 
+# Format for a pointer.
+POINTER_STRUCT = struct.Struct("<Q")
+
 
 def Flatten(value):
   """Flattens nested lists/tuples into an one-level list. If value is not a
      list/tuple, it is converted to an one-item list. For example,
      (1, 2, [3, 4, ('56', '7')]) is converted to [1, 2, 3, 4, '56', '7'];
      1 is converted to [1].
   """
   if isinstance(value, (list, tuple)):
     result = []
     for item in value:
@@ skipping 188 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):

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

This code needs comments. I find it really hard to understand what happens.

[azani, 2015/07/17 20:38:15]

I have added some comments. Let me know if they provide enough clarification.

+  """
+  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/17 10:53:58]

If you cannot do usual instanceof calls, then adds a is_union() method to the
type object. I really do not like this.

[azani, 2015/07/17 20:38:15]

Done.

+      nested_union = bytearray(16)
+      HEADER_STRUCT.pack_into(nested_union, 0, entry[0], entry[1])
+      POINTER_STRUCT.pack_into(nested_union, 8, entry[2])
+
+      data = nested_union + data
+      entry = 8
+
+    return (16, union.tag, entry, data), handles

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

I am clearly missing something.

Let say that you are trying to encode an union containing a struct. Then entry
will be the content of the struct. Let's say this struct has not pointers, so
data will be empty.

Then when you try to serialize this union, how will that work? From what I
understand, this will ends up in line 263, when you will encode the full contant
of the struct as an Uint64. What am I missing? I don't understand how this will
be transformed into the right pointer to the struct content.

[azani, 2015/07/17 20:38:16]

In your exampled Serialize is PointerType.Serialize at descriptor.py:201 and it
calls StructType.SerializePointer which is at descriptor.py:565.
SerializePointer will actually append the struct to data and return data_offset.
So in the case you describe above, entry is actually a pointer to the serialized
struct data and the serialize struct data got appended to data.

+
+  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 = POINTER_STRUCT.unpack_from(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