def __init__(self, native, *args, **kwargs):
ReflectedType.__init__(self, *args, **kwargs)
try:
self._native = native.decode("utf-8")
except UnicodeError:
self._native = native
def __init__(self, ref, *args, **kwargs):
ReflectedType.__init__(self, *args, **kwargs)
self._ref = ref
self._class = None
self._field_names = set()
self._not_field_names = set(['_ref', 'getField'])
def __setattr__(self, attr, value):
if attr.startswith('_'):
object.__setattr__(self, attr, value)
return
if attr in self._field_names:
return self._reflector.setProperty(self, attr, ReflectedType.fromNative(value, reflector=self._reflector))
if attr not in self._not_field_names:
try:
return self._reflector.setProperty(self, attr, ReflectedType.fromNative(value, reflector=self._reflector))
except ReflectionException:
self._not_field_names.add(attr)
def _invoker(self, method_name, *args, **kwargs):
"""
Invokes methods on the object, in the Java VM, proxying through the
reflector's invoke() method.
"""
result = self._reflector.invoke(self, method_name, *map(lambda arg: ReflectedType.fromNative(arg, reflector=self._reflector), args), **kwargs)
return result
def fromArgument(cls, argument, reflector):
"""
Builds a new ReflectedArray, given an Argument as defined in the Mercury
protocol that contains an Array.
"""
array = []
for element in argument.array.element:
array.append(ReflectedType.fromArgument(element, reflector))
return ReflectedArray(array, reflector=reflector)
def __validateAndConvert(self, objects):
"""
A utility method to help build a ReflectedArray from a collection of
other objects.
This enforces some validation, such as checking that all objects in an
array are of consistent type.
"""
if not hasattr(objects, '__iter__'):
raise TypeError("objects is not iterable")
list_type = None
for obj in objects:
if not list_type:
list_type = type(obj)
else:
if type(obj) != list_type:
raise TypeError("mismatched array element types")
yield ReflectedType.fromNative(obj, self._reflector)
def _pb(self):
"""
Get an Argument representation of the Array, as defined in the Mercury
protocol.
"""
argument = Message.Argument(type=Message.Argument.ARRAY)
if self._native[0]._pb().type == Message.Argument.ARRAY:
argument.array.type = Message.Array.ARRAY
elif self._native[0]._pb().type == Message.Argument.NULL:
argument.array.type = Message.Array.OBJECT
elif self._native[0]._pb().type == Message.Argument.OBJECT:
argument.array.type = Message.Array.OBJECT
elif self._native[0]._pb().type == Message.Argument.STRING:
argument.array.type = Message.Array.STRING
elif self._native[0]._pb().type == Message.Argument.PRIMITIVE:
argument.array.type = Message.Array.PRIMITIVE
for e in self._native:
element = argument.array.element.add()
element.MergeFrom(ReflectedType.fromNative(e, reflector=self._reflector)._pb())
return argument
def __init__(self, primitive_type, native, *args, **kwargs):
ReflectedType.__init__(self, *args, **kwargs)
self._type = primitive_type
self._native = native
def __ne__(self, other):
if(other == None):
return False
else:
return ReflectedType.__ne__(self, other)
def __eq__(self, other):
if(other == None):
return True
else:
return ReflectedType.__eq__(self, other)
def __init__(self, native, *args, **kwargs):
ReflectedType.__init__(self, *args, **kwargs)
self._native = native
def __init__(self, native, *args, **kwargs):
ReflectedType.__init__(self, *args, **kwargs)
self._native = native
def __init__(self, objects, *args, **kwargs):
ReflectedType.__init__(self, *args, **kwargs)
self._native = list(self.__validateAndConvert(objects))
def insert(self, i, obj):
self._native.insert(i, ReflectedType.fromNative(obj, self._reflector))
def append(self, obj):
self._native.append(ReflectedType.fromNative(obj, self._reflector))
return self
def __setitem__(self, index, obj):
self._native[index] = ReflectedType.fromNative(obj, self._reflector)
