def to_data(self, obj, partitioning_strategy=None):
"""Serialize the input object into byte array representation
Args:
obj: Input object
partitioning_strategy (function): Function in the form of ``lambda key: partitioning_key``.
Returns:
hazelcast.serialization.data.Data: Data object
"""
if obj is None:
return None
if isinstance(obj, Data):
return obj
out = _ObjectDataOutput(self._output_buffer_size, self,
self._is_big_endian)
try:
serializer = self._registry.serializer_for(obj)
partitioning_hash = self._calculate_partitioning_hash(
obj, partitioning_strategy)
out.write_int_big_endian(partitioning_hash)
out.write_int_big_endian(serializer.get_type_id())
serializer.write(out, obj)
return Data(out.to_byte_array())
except:
handle_exception(sys.exc_info()[1], sys.exc_info()[2])
def test_data(self):
self.mark_initial_frame_as_non_final()
data = Data("123456789".encode("utf-8"))
DataCodec.encode(self.buf, data)
DataCodec.encode_nullable(self.buf, data)
DataCodec.encode_nullable(self.buf, None, True)
message = self.write_and_decode()
message.next_frame() # initial frame
self.assertEqual(data, DataCodec.decode(message))
self.assertEqual(data, DataCodec.decode_nullable(message))
self.assertIsNone(DataCodec.decode_nullable(message))
def _big_int_test(self, big_int):
script = """from java.math import BigInteger
result=instance_0.getSerializationService().toBytes(BigInteger("{}",10))""".format(
big_int)
response = self.rc.executeOnController(self.cluster.id, script,
Lang.PYTHON)
data = Data(response.result)
val = self.service.to_object(data)
data_local = self.service.to_data(big_int)
self.assertEqual(binascii.hexlify(data._buffer),
binascii.hexlify(data_local._buffer))
self.assertEqual(big_int, val)
def test_datetime(self):
year = 2000
month = 11
day = 15
hour = 23
minute = 59
second = 49
script = """
from java.util import Date, Calendar
cal = Calendar.getInstance()
cal.set({}, ({}-1), {}, {}, {}, {})
result=instance_0.getSerializationService().toBytes(cal.getTime())
""".format(year, month, day, hour, minute, second)
response = self.rc.executeOnController(self.cluster.id, script,
Lang.PYTHON)
data = Data(response.result)
val = self.service.to_object(data)
self.assertEqual(year, val.year)
self.assertEqual(month, val.month)
self.assertEqual(day, val.day)
self.assertEqual(hour, val.hour)
self.assertEqual(minute, val.minute)
self.assertEqual(second, val.second)
def test_serialize_data(self):
data = Data(bytearray(0))
obj = self.service.to_data(data)
self.assertTrue(isinstance(obj, Data))
def test_null_data(self):
data = Data(bytearray(0))
obj = self.service.to_object(data)
self.assertIsNone(obj)
def read_data(self):
buff = self.read_byte_array()
return Data(buff) if buff is not None else None
def _read_data_from_inp(inp):
buff = inp.read_byte_array()
return Data(buff) if buff is not None else None
list(
map(_to_unicode, [
"Pijamalı hasta, yağız şoföre çabucak güvendi.",
"イロハニホヘト チリヌルヲ ワカヨタレソ ツネナラム",
"The quick brown fox jumps over the lazy dog"
])),
"Date":
datetime.datetime.fromtimestamp(633830400),
"BigInteger":
1314432323232411,
"Class":
_to_unicode("java.math.BigDecimal"),
}
_data = Data(
bytearray([
49, 49, 49, 51, 49, 51, 49, 50, 51, 49, 51, 49, 51, 49, 51, 49, 51, 49
]))
_inner_portable = AnInnerPortable(REFERENCE_OBJECTS["Integer"],
REFERENCE_OBJECTS["Float"])
_custom_serializable = CustomStreamSerializable(REFERENCE_OBJECTS["Integer"],
REFERENCE_OBJECTS["Float"])
_custom_byte_array_serializable = CustomByteArraySerializable(
REFERENCE_OBJECTS["Integer"], REFERENCE_OBJECTS["Float"])
_identified = AnIdentifiedDataSerializable(
REFERENCE_OBJECTS["Boolean"], REFERENCE_OBJECTS["Byte"],
REFERENCE_OBJECTS["Character"], REFERENCE_OBJECTS["Double"],
REFERENCE_OBJECTS["Short"], REFERENCE_OBJECTS["Float"],
def _read_data_from(inp):
array = inp.read_byte_array()
if array is None:
return None
return Data(array)
def decode(msg):
return Data(msg.next_frame().buf)
def test_utf8_decode(self):
data_byte = to_data_byte(TEST_DATA_ALL)
data = Data(data_byte)
actual_ascii = self.service.to_object(data)
self.assertEqual(TEST_DATA_ALL, actual_ascii)
def test_ascii_decode(self):
data_byte = to_data_byte(TEST_DATA_ASCII)
data = Data(buff=data_byte)
actual_ascii = self.service.to_object(data)
self.assertEqual(TEST_DATA_ASCII, actual_ascii)
def test_float(self):
buff = bytearray(binascii.unhexlify("00000000fffffff700000000"))
data = Data(buff)
obj = self.service.to_object(data)
self.assertEqual(0.0, obj)
def test_char_type_serializer(self):
buff = bytearray(binascii.unhexlify("00000000fffffffb00e7"))
data = Data(buff)
obj = self.service.to_object(data)
self.assertEqual(unichr(0x00e7), obj)
def test_none_serializer(self):
none = None
data_n = self.service.to_data(none)
self.assertIsNone(data_n)
self.assertIsNone(self.service.to_object(Data()))
