Implement python mojo bindings unions.

mojo/public/python/mojo_bindings/reflection.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.
 
 """The metaclasses used by the mojo python bindings."""
 
 import itertools
 
 # pylint: disable=F0401
 import mojo_bindings.serialization as serialization
@@ skipping 90 matching lines @@
 
     # Add init
     dictionary['__init__'] = _StructInit(fields)
 
     # Add serialization method
     serialization_object = serialization.Serialization(groups)
     def Serialize(self, handle_offset=0):
       return serialization_object.Serialize(self, handle_offset)
     dictionary['Serialize'] = Serialize
 
+    dictionary['GetS'] = classmethod(lambda s: serialization_object)

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

What is this? I didn't find where it was used? By anyway, this should not be
there. We do not want to add random method to the public interface of those
objects.

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

Sorry, that was here for debugging.

+
     # pylint: disable=W0212
     def AsDict(self):
       return self._fields
     dictionary['AsDict'] = AsDict
 
     def Deserialize(cls, context):
       result = cls.__new__(cls)
       fields = {}
       serialization_object.Deserialize(fields, context)
       result._fields = fields
       return result
     dictionary['Deserialize'] = classmethod(Deserialize)
 
     dictionary['__eq__'] = _StructEq(fields)
     dictionary['__ne__'] = _StructNe
 
     return type.__new__(mcs, name, bases, dictionary)
 
   # Prevent adding new attributes, or mutating constants.
   def __setattr__(cls, key, value):
     raise AttributeError('can\'t set attribute')
 
   # Prevent deleting constants.
   def __delattr__(cls, key):
     raise AttributeError('can\'t delete attribute')
 
 
+class MojoUnionType(type):
+
+  def __new__(mcs, name, bases, dictionary):
+    dictionary['__slots__'] = ('_fields', '_tags', '_tag', '_data')
+    descriptor = dictionary.pop('DESCRIPTOR', {})
+
+    fields = descriptor.get('fields', [])
+    def _BuildUnionProperty(field):
+
+      # pylint: disable=W0212
+      def Get(self):
+        if self._tag != self._tags[field.name]:

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

I might be wrong, but I think you do not need to put _tags in self. You can
instead just define it in the function and reference it by, as it will capture
the value. Kind of this:

def f():
  l = []
  def getL():
    return l
  return getL


g1 = f()
g2 = f()
g1() => []
g2() => []
g1().append(1)
g1() => [1]
g2() => []

Same for _tag_names

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

Done.

+          raise AttributeError('%s is not currently set' % field.name,
+              field.name, self._tag_names[self._tag])
+        return self._data
+
+      # pylint: disable=W0212
+      def Set(self, value):
+        self._tag = self._tags[field.name]
+        self._data = field.field_type.Convert(value)
+
+      return property(Get, Set)
+
+    for field in fields:
+      dictionary[field.name] = _BuildUnionProperty(field)
+
+    dictionary['_tags'] = {field.name: field.index for field in fields}
+    dictionary['_tag_names'] = {field.index: field.name for field in fields}
+
+    def UnionInit(self, **kwargs):
+      items = kwargs.items()
+      if len(items) == 0:
+        return
+
+      if len(items) > 1:
+        raise TypeError('only 1 member may be set on a union.')
+
+      setattr(self, items[0][0], items[0][1])
+    dictionary['__init__'] = UnionInit
+
+    serializer = serialization.UnionSerializer(fields)
+    def SerializeUnionInline(self, handle_offset=0):
+      return serializer.SerializeInline(self, handle_offset)
+    dictionary['SerializeInline'] = SerializeUnionInline
+
+    def SerializeUnion(self, handle_offset=0):
+      return serializer.Serialize(self, handle_offset)
+    dictionary['Serialize'] = SerializeUnion
+
+    def DeserializeUnion(cls, context):
+      return serializer.Deserialize(context, cls)
+    dictionary['Deserialize'] = classmethod(DeserializeUnion)
+
+    def GetTag(self):
+      return self._tag
+    dictionary['tag'] = property(GetTag, None)

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

What can I compare tag with? I think you are missing the generation of an enum
with all the possible values. You are not testing this either BTW.

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

Done.

+
+    def GetData(self):
+      return self._data
+    dictionary['data'] = property(GetData, None)
+
+    def UnionEq(self, other):
+      return (
+          (type(self) is type(other))
+          and (self.tag == other.tag)
+          and (self.data == other.data))
+    dictionary['__eq__'] = UnionEq
+
+    def UnionNe(self, other):
+      return not self.__eq__(other)
+    dictionary['__ne__'] = UnionNe
+
+    def UnionStr(self):
+      return '<%s.%s(%s): %s>' % (
+          self.__class__.__name__,
+          self._tag_names[self.tag],
+          self.tag,
+          self.data)
+    dictionary['__str__'] = UnionStr
+    dictionary['__repr__'] = UnionStr
+
+    return type.__new__(mcs, name, bases, dictionary)
+
+
+class UnionData(object):
+  __slots__ = ('data', 'tag')

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

What is this used for.

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

Sorry, left over from previous iteration.

+
+
+
+
 class InterfaceRequest(object):
   """
   An interface request allows to send a request for an interface to a remote
   object and start using it immediately.
   """
 
   def __init__(self, handle):
     self._handle = handle
 
   def IsPending(self):
@@ skipping 56 matching lines @@
     if type(self) is not type(other):
       return False
     for field in fields:
       if getattr(self, field.name) != getattr(other, field.name):
         return False
     return True
   return _Eq
 
 def _StructNe(self, other):
   return not self.__eq__(other)