def _v_vse_decoder(cls, value, *tags):
"""Create object from VSE tag data"""
if tags:
raise VTaggedParseError('Encoding does not use residual tags')
value = VEntity._v_lazy_native(value)
if not isinstance(value, bytes):
raise VTaggedParseError('Encoding value must be bytes data')
_nums = []
_offset = 0
while value:
_num, _b_read = netbytes_to_signedint(value)
if _num is None:
raise VTaggedParseError('Invalid number encoding')
_nums.append(_num)
value = value[_b_read:]
if len(_nums) % 3 != 0:
raise VTaggedParseError('Invalid number encoding')
_vals = []
for i in xrange(len(_nums) // 3):
_digits = _nums[3 * i]
_base = _nums[3 * i + 1]
_exp = _nums[3 * i + 2]
_vals.append(VFloat(_digits, _exp, base=_base))
result = VArrayOfVFloat(_vals)
return (lambda x: x[0], [result])
def __init__(self, prefix, postfix):
# Validate appropriate type
_tmp = []
if _pyver == 2:
_ftyp, _ttyp = str, unicode
else:
_ftyp, _ttyp = bytes, str
for _val in prefix, postfix:
if isinstance(_val, _ftyp):
try:
_val = _ttyp(_val)
except Exception as e:
raise TypeError('Pre/postfix must be (unicode) strings.')
if isinstance(_val, _ttyp):
_tmp.append(_val)
else:
raise TypeError('Pre/postfix must be (unicode) strings.')
prefix, postfix = _tmp
# Check valid prefix
if '://' not in prefix:
raise ValueError('Invalid prefix, must contain *://*/*')
_tmp = prefix.split('://')
_method, _residual = _tmp[0], '://'.join(_tmp[1:])
if not _residual or not _residual.endswith('/'):
raise VTaggedParseError('Invalid prefix, must contain *://*/')
if not _method == _method.lower():
raise VTaggedParseError('Invalid prefix, *:// must be lower case')
super(VUrlConcept, self).__init__(VConcept.TYPE_URL, (prefix, postfix))
def _v_vse_decoder(cls, value, *tags):
"""Create object from VSE tag data"""
if tags:
raise VTaggedParseError('Encoding does not use residual tags')
if not isinstance(value, VTuple):
raise VTaggedParseError('Encoding value must be a tuple')
return (cls, list(value))
def _v_vse_decoder(cls, value, *tags):
"""Create object from VSE tag data"""
if tags:
raise VTaggedParseError('Encoding takes no residual tags')
if not isinstance(value, (VTuple, tuple)) or len(value) != 2:
raise VTaggedParseError('Value must be a 2-tuple')
_quantity, _unit = value
return (lambda args: VDimensionalQuantity(*args), [_quantity, _unit])
def _v_vse_decoder(cls, value, *tags):
"""Create object from VSE tag data"""
if tags:
raise VTaggedParseError('Encoding takes no residual tags')
if not isinstance(value, (tuple, VTuple)) or len(value) != 2:
raise VTaggedParseError('Value must be a 2-tuple')
_prefix, _unit = value
return (lambda args: VPrefixedUnit(*args), [_prefix, _unit])
def _v_vse_decoder(cls, value, *tags):
"""Returns decoder for :class:`versile.orb.entity.VTagged`."""
if tags:
raise VTaggedParseError('Encoding should have no residual tags')
if isinstance(value, VObject):
value = value._v_proxy()
if not isinstance(value, VProxy):
raise VTaggedParseError('Encoding value must be object reference')
return (lambda x: cls(*x), [value])
def _assemble(args):
keys, values = value[0:l:2], value[1:l:2]
data = dict()
for key, val in zip(keys, values):
if key in data:
raise VTaggedParseError('Duplicate keys')
data[key] = val
try:
return cls(data)
except:
raise VTaggedParseError('Error initializing dictionary')
def _v_vse_decoder(cls, value, *tags):
"""Returns decoder for :class:`versile.orb.entity.VTagged`."""
if not tags or len(tags) != 1:
raise VTaggedParseError('Encoding must have one residual tag tag')
is_client = tags[0]
if not isinstance(is_client, (bool, VBoolean)):
raise VTaggedParseError('Residual tag must be boolean')
if isinstance(value, VObject):
value = value._v_proxy()
if not isinstance(value, VProxy):
raise VTaggedParseError('Encoding value must be object reference')
return (lambda x: cls(*x), [value, is_client])
def __init__(self, obj, tag):
if not isinstance(obj, VReference):
if isinstance(obj, VNativeObject):
if obj._v_native_tag() != tag:
raise VTaggedParseError('VNative tag mismatch')
else:
raise VTaggedParseError('Not a VReference or VNativeObject')
VEntity.__init__(self)
self._v_int_native_obj = obj._v_proxy()
self._v_tag = tag
self._v_active = False
def _v_vse_decoder(cls, value, *tags):
"""Create object from VSE tag data"""
if tags:
raise VTaggedParseError('Encoding does not use residual tags')
value = VEntity._v_lazy_native(value)
if not isinstance(value, bytes):
raise VTaggedParseError('Encoding value must be bytes data')
if len(value) % 8 != 0:
raise VTaggedParseError('Encoding must be multiple of 8 bytes')
_nums = []
_offset = 0
while _offset < len(value):
_nums.append(struct.unpack_from(b'>d', value, _offset)[0])
_offset += 8
result = VArrayOfDouble(_nums)
return (lambda x: x[0], [result])
def _v_vse_decoder(cls, value, *tags):
"""Create object from VSE tag data"""
if tags:
raise VTaggedParseError('Encoding does not use residual tags')
value = VEntity._v_lazy_native(value)
if not isinstance(value, bytes):
raise VTaggedParseError('Encoding value must be bytes data')
_nums = []
_offset = 0
while value:
_num, _b_read = netbytes_to_signedint(value)
if _num is None:
raise VTaggedParseError('Invalid number encoding')
_nums.append(_num)
value = value[_b_read:]
result = VArrayOfVInteger(_nums)
return (lambda x: x[0], [result])
def _v_vse_decoder(cls, value, *tags):
"""Returns decoder for :class:`versile.orb.entity.VTagged`."""
if len(tags) != 2:
raise VTaggedParseError('Encoding requires 2 residual tags')
min_arg, max_arg = tags
min_arg = VEntity._v_lazy_native(min_arg)
max_arg = VEntity._v_lazy_native(max_arg)
for arg in (min_arg, max_arg):
if arg is None:
continue
if isinstance(arg, (int, long)) and arg >= 0:
continue
raise VTaggedParseError('Limit must be non-negative int or None')
if min_arg is not None and max_arg is not None and max_arg < min_arg:
raise VTaggedParseError('Max arguments must be None or > min args')
if isinstance(value, VObject):
value = value._v_proxy()
if not isinstance(value, VProxy):
raise VTaggedParseError('Encoding value must be object reference')
return (lambda x: cls(*x), [value, min_arg, max_arg])
def _vse_exc_decoder(self, value, *tags):
if len(tags) != 1 or not isinstance(tags[0], VString):
raise VTaggedParseError('Invalid residual tag format')
residual_tag = VEntity._v_lazy_native(tags[0])
if not isinstance(tags, (tuple, VTuple)):
raise VTaggedParseError('Invalid value format')
self.__lock.acquire()
try:
decoders = self.__handlers.get(residual_tag, None)
finally:
self.__lock.release()
if decoders:
obj_decoder, exc_decoder = decoders
decoded = exc_decoder(*value)
else:
decoded = VNativeException(residual_tag, *value)
if self.__activates:
decoded._v_activate()
return (lambda args: decoded, [])
def converter(self, obj):
self.__lock.acquire()
try:
entry = None
if isinstance(obj, object) and hasattr(obj, '__class__'):
c = obj.__class__
try:
entry = self.__proxy.converter_from_class(c)
except VModuleError:
pass
if not entry:
try:
entry = self.__proxy.converter_from_type(type(obj))
except VModuleError:
pass
if not entry:
raise VTaggedParseError('Could not find a converter')
try:
return entry.converter(obj)
except Exception as e:
raise VTaggedParseError('Error creating converter')
finally:
self.__lock.release()
def _v_vse_decoder(cls, value, *tags):
"""Returns decoder for :class:`versile.orb.entity.VTagged`."""
if tags:
raise VTaggedParseError('Encoding does not use residual tags')
if not isinstance(value, VTuple):
raise VTaggedParseError('Encoding value must be a tuple')
l = len(value)
if l % 2:
raise VTaggedParseError('Value length must be an even number')
def _assemble(args):
keys, values = value[0:l:2], value[1:l:2]
data = dict()
for key, val in zip(keys, values):
if key in data:
raise VTaggedParseError('Duplicate keys')
data[key] = val
try:
return cls(data)
except:
raise VTaggedParseError('Error initializing dictionary')
return (_assemble, list(value))
def decoder(self, obj):
self.__lock.acquire()
try:
if not isinstance(obj, VTagged):
raise VTaggedParseError('Object must be VTagged')
value, tags = obj.value, obj.tags
if not tags:
raise VTaggedParseUnknown('No tags set on object')
encoding, etags = VEntity._v_lazy_native(tags[0]), tags[1:]
if not isinstance(encoding, (int, long) or encoding < -1):
raise VTaggedParseUnknown()
if encoding == -1:
if len(etags) < 2:
raise VTaggedParseError()
name, version = VEntity._v_lazy_native(etags[:2])
mod_tags = etags[2:]
try:
entry = self.__proxy.decoder_from_name(name, version)
except VModuleError:
raise VTaggedParseUnknown()
try:
return entry.decoder(value, *mod_tags)
except Exception as e:
raise VTaggedParseError(e.args)
oid_enc_type, oid_enc_len = encoding % 10, encoding // 10
if oid_enc_type in (0, 1):
if len(etags) < oid_enc_len:
raise VTaggedParseError()
oid_tags, mod_tags = etags[:oid_enc_len], etags[oid_enc_len:]
oid_tags = VEntity._v_lazy_native(oid_tags)
for t in oid_tags:
if not isinstance(t, (int, long)) or t < 0:
raise VTaggedParseError()
else:
return VTaggedParseUnknown()
if oid_enc_type == 1:
oid_tags = self.VSE_OID_PREFIX + oid_tags
oid = VObjectIdentifier(oid_tags)
try:
entry = self.__proxy.decoder_from_oid(oid)
except VModuleError:
raise VTaggedParseUnknown()
try:
return entry.decoder(value, *mod_tags)
except Exception as e:
raise VTaggedParseError(e.args)
finally:
self.__lock.release()
def _v_vse_decoder(cls, value, *tags):
"""Create object from VSE tag data"""
if len(tags) != 1:
raise VTaggedParseError('Encoding requires a single residual tag')
tag = tags[0]
if _pyver == 2:
_itypes = (int, long, VInteger)
else:
_itypes = (int, VInteger)
if not isinstance(tag, _itypes):
raise VTaggedParseError('Residual tag must be an integer')
_val = VEntity._v_lazy_native(value)
if tag == VConcept.TYPE_URL:
if not isinstance(_val, tuple) or len(_val) != 2:
raise VTaggedParseError('Value must be an 2-tuple')
for _tmp in _val:
if _pyver == 2:
if not isinstance(_tmp, unicode):
raise VTaggedParseError('Value element must be string')
else:
if not isinstance(_tmp, str):
raise VTaggedParseError('Value element must be string')
_prefix, _postfix = _val
try:
_result = VUrlConcept.create(_prefix, _postfix)
except Exception as e:
raise VTaggedParseError(e)
else:
return (lambda x: _result, [])
if tag == VConcept.TYPE_EN_WIKIPEDIA:
if _pyver == 2:
if not isinstance(_val, unicode):
raise VTaggedParseError('Value must be string')
else:
if not isinstance(_val, str):
raise VTaggedParseError('Value must be string')
try:
_result = VEnWikipediaConcept.create(_val)
except Exception as e:
raise VTaggedParseError(e)
else:
return (lambda x: _result, [])
if tag == VConcept.TYPE_VP_DEFINED:
if not isinstance(value, _itypes):
raise VTaggedParseError('Value must be an integer')
_val = VEntity._v_lazy_native(value)
try:
_result = VPlatformConcept.create(_val)
except Exception as e:
raise VTaggedParseError(e)
else:
return (lambda x: _result, [])
raise VTaggedParseError('Invalid residual tag value')