mojo: Specialize native type arrays.

mojo/public/python/mojo/bindings/descriptor.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 descriptors used to define generated elements of the mojo python bindings.
 """
 
+import array
+
 # pylint: disable=F0401
 from mojo.system import Handle
 
 class Type(object):
   """Describes the type of a struct field or a method parameter,"""
 
   def Convert(self, value): # pylint: disable=R0201
     """
     Convert the given value into its canonical representation, raising an
     exception if the value cannot be converted.
@@ skipping 33 matching lines @@
     self.signed = signed
     if self.signed:
       self._min_value = -(1 << (size - 1))
       self._max_value = (1 << (size - 1)) - 1
     else:
       self._min_value = 0
       self._max_value = (1 << size) - 1
 
   def Convert(self, value):
     if value is None:
-      raise ValueError('None is not an integer.')
+      raise TypeError('None is not an integer.')
     if not isinstance(value, (int, long)):
-      raise ValueError('%r is not an integer type' % value)
+      raise TypeError('%r is not an integer type' % value)
     if value < self._min_value or value > self._max_value:
-      raise ValueError('%r is not in the range [%d, %d]' %
+      raise OverflowError('%r is not in the range [%d, %d]' %
                        (value, self._min_value, self._max_value))

[sdefresne, 2014/09/10 08:40:00]

nit: indent

[qsr, 2014/09/10 09:23:38]

Done.

     return value
 
 
 class FloatType(NumericType):
   """Type object for floating point number types."""
 
   def __init__(self, size):
     NumericType.__init__(self)
     self.size = size
 
   def Convert(self, value):
     if value is None:
-      raise ValueError('None is not an floating point number.')
+      raise TypeError('None is not an floating point number.')
     if not isinstance(value, (int, long, float)):
-      raise ValueError('%r is not a numeric type' % value)
+      raise TypeError('%r is not a numeric type' % value)
     return float(value)
 
 
 class StringType(Type):
   """
   Type object for strings.
 
   Strings are represented as unicode, and the conversion is done using the
   default encoding if a string instance is used.
   """
 
   def __init__(self, nullable=False):
     Type.__init__(self)
     self.nullable = nullable
 
   def Convert(self, value):
     if value is None or isinstance(value, unicode):
       return value
     if isinstance(value, str):
       return unicode(value)
-    raise ValueError('%r is not a string' % value)
+    raise TypeError('%r is not a string' % value)
 
 
 class HandleType(Type):
   """Type object for handles."""
 
   def __init__(self, nullable=False):
     Type.__init__(self)
     self.nullable = nullable
 
   def Convert(self, value):
     if value is None:
       return Handle()
     if not isinstance(value, Handle):
-      raise ValueError('%r is not a handle' % value)
+      raise TypeError('%r is not a handle' % value)
     return value
 
 
-class ArrayType(Type):
-  """Type object for arrays."""
+class GenericArrayType(Type):
+  """Abstract Type object for arrays."""
+
+  def __init__(self, nullable=False, length=0):
+    Type.__init__(self)
+    self.nullable = nullable
+    self.length = length
+
+
+class PointerArrayType(GenericArrayType):
+  """Type object for arrays of pointers."""
 
   def __init__(self, sub_type, nullable=False, length=0):
-    Type.__init__(self)
+    GenericArrayType.__init__(self, nullable, length)
     self.sub_type = sub_type
-    self.nullable = nullable
-    self.length = length
 
   def Convert(self, value):
     if value is None:
       return value
     return [self.sub_type.Convert(x) for x in value]
 
 
+class NativeArrayType(GenericArrayType):
+  """Type object for arrays of native types."""
+
+  def __init__(self, typecode, nullable=False, length=0):
+    GenericArrayType.__init__(self, nullable, length)
+    self.typecode = typecode
+
+  def Convert(self, value):
+    if value is None:
+      return value
+    if isinstance(value, array.array) and value.typecode == self.typecode:
+      return value
+    return array.array(self.typecode, value)
+
+
 class StructType(Type):
   """Type object for structs."""
 
   def __init__(self, struct_type, nullable=False):
     Type.__init__(self)
     self.struct_type = struct_type
     self.nullable = nullable
 
   def Convert(self, value):
     if value is None or isinstance(value, self.struct_type):
       return value
-    raise ValueError('%r is not an instance of %r' % (value, self.struct_type))
+    raise TypeError('%r is not an instance of %r' % (value, self.struct_type))
 
   def GetDefaultValue(self, value):
     if value:
       return self.struct_type()
     return None
 
 
 class NoneType(Type):
   """Placeholder type, used temporarily until all mojo types are handled."""
 
@@ skipping 31 matching lines @@
   def __init__(self, name, field_type, offset,
                bit_offset=None, default_value=None):
     self.name = name
     self.field_type = field_type
     self.offset = offset
     self.bit_offset = bit_offset
     self._default_value = default_value
 
   def GetDefaultValue(self):
     return self.field_type.GetDefaultValue(self._default_value)