diff --git a/docs/serialization.rst b/docs/serialization.rst index b9e0e9e726..c5a2ae0d79 100644 --- a/docs/serialization.rst +++ b/docs/serialization.rst @@ -98,16 +98,16 @@ The following is an example of a class that extends return 1 def write_data(self, output): - output.write_utf(self.street) + output.write_string(self.street) output.write_int(self.zip_code) - output.write_utf(self.city) - output.write_utf(self.state) + output.write_string(self.city) + output.write_string(self.state) def read_data(self, input): - self.street = input.read_utf() + self.street = input.read_string() self.zip_code = input.read_int() - self.city = input.read_utf() - self.state = input.read_utf() + self.city = input.read_string() + self.state = input.read_string() .. Note:: Refer to ``ObjectDataInput``/``ObjectDataOutput`` classes in @@ -199,10 +199,10 @@ following: return 1 def write_portable(self, writer): - writer.write_utf("foo", self.foo) + writer.write_string("foo", self.foo) def read_portable(self, reader): - self.foo = reader.read_utf("foo") + self.foo = reader.read_string("foo") .. Note:: Refer to ``PortableReader``/``PortableWriter`` classes in the @@ -299,12 +299,12 @@ Foo class: return 2 def write_portable(self, writer): - writer.write_utf("foo", self.foo) - writer.write_utf("foo2", self.foo2) + writer.write_string("foo", self.foo) + writer.write_string("foo2", self.foo2) def read_portable(self, reader): - self.foo = reader.read_utf("foo") - self.foo2 = reader.read_utf("foo2") + self.foo = reader.read_string("foo") + self.foo2 = reader.read_string("foo2") You should consider the following when you perform versioning: @@ -377,10 +377,10 @@ Let’s say your custom ``MusicianSerializer`` will serialize pass def write(self, output, obj): - output.write_utf(obj.name) + output.write_string(obj.name) def read(self, input): - name = input.read_utf() + name = input.read_string() return Musician(name) Note that the serializer ``id`` must be unique as Hazelcast will use it @@ -487,10 +487,10 @@ is shown below. pass def write(self, output, obj): - output.write_utf(some_third_party_serializer.serialize(obj)) + output.write_string(some_third_party_serializer.serialize(obj)) def read(self, input): - return some_third_party_serializer.deserialize(input.read_utf()) + return some_third_party_serializer.deserialize(input.read_string()) You should register the global serializer to the client. diff --git a/docs/using_python_client_with_hazelcast_imdg.rst b/docs/using_python_client_with_hazelcast_imdg.rst index b9e8483dc7..7b8ab05bd8 100644 --- a/docs/using_python_client_with_hazelcast_imdg.rst +++ b/docs/using_python_client_with_hazelcast_imdg.rst @@ -1150,10 +1150,10 @@ The following is an example for ``EntryProcessor`` which is an self.value = value def read_data(self, object_data_input): - self.value = object_data_input.read_utf() + self.value = object_data_input.read_string() def write_data(self, object_data_output): - object_data_output.write_utf(self.value) + object_data_output.write_string(self.value) def get_factory_id(self): return 5 @@ -1364,13 +1364,13 @@ Assume that you have an ``employee`` map containing the instances of return 1000 def read_portable(self, reader): - self.name = reader.read_utf("name") + self.name = reader.read_string("name") self.age = reader.read_int("age") self.active = reader.read_boolean("active") self.salary = reader.read_double("salary") def write_portable(self, writer): - writer.write_utf("name", self.name) + writer.write_string("name", self.name) writer.write_int("age", self.age) writer.write_boolean("active", self.active) writer.write_double("salary", self.salary) diff --git a/examples/map/map_portable_query_example.py b/examples/map/map_portable_query_example.py index 5fec113c73..96407af27c 100644 --- a/examples/map/map_portable_query_example.py +++ b/examples/map/map_portable_query_example.py @@ -14,11 +14,11 @@ def __init__(self, name=None, age=None): self.age = age def write_portable(self, writer): - writer.write_utf("name", self.name) + writer.write_string("name", self.name) writer.write_int("age", self.age) def read_portable(self, reader): - self.name = reader.read_utf("name") + self.name = reader.read_string("name") self.age = reader.read_int("age") def get_factory_id(self): diff --git a/examples/map/map_portable_versioning_example.py b/examples/map/map_portable_versioning_example.py index b41de5448a..80d7c0a488 100644 --- a/examples/map/map_portable_versioning_example.py +++ b/examples/map/map_portable_versioning_example.py @@ -20,11 +20,11 @@ def __init__(self, name=None, age=None): self.age = age def write_portable(self, writer): - writer.write_utf("name", self.name) + writer.write_string("name", self.name) writer.write_int("age", self.age) def read_portable(self, reader): - self.name = reader.read_utf("name") + self.name = reader.read_string("name") self.age = reader.read_int("age") def get_factory_id(self): @@ -57,14 +57,14 @@ def __init__(self, name=None, age=None, manager=None): self.manager = manager def write_portable(self, writer): - writer.write_utf("name", self.name) + writer.write_string("name", self.name) writer.write_int("age", self.age) - writer.write_utf("manager", self.manager) + writer.write_string("manager", self.manager) def read_portable(self, reader): - self.name = reader.read_utf("name") + self.name = reader.read_string("name") self.age = reader.read_int("age") - self.manager = reader.read_utf("manager") + self.manager = reader.read_string("manager") def get_factory_id(self): return self.FACTORY_ID @@ -103,14 +103,14 @@ def __init__(self, name=None, age=None, manager=None): self.manager = manager def write_portable(self, writer): - writer.write_utf("name", self.name) - writer.write_utf("age", self.age) - writer.write_utf("manager", self.manager) + writer.write_string("name", self.name) + writer.write_string("age", self.age) + writer.write_string("manager", self.manager) def read_portable(self, reader): - self.name = reader.read_utf("name") - self.age = reader.read_utf("age") - self.manager = reader.read_utf("manager") + self.name = reader.read_string("name") + self.age = reader.read_string("age") + self.manager = reader.read_string("manager") def get_factory_id(self): return self.FACTORY_ID diff --git a/examples/org-website/custom_serializer_sample.py b/examples/org-website/custom_serializer_sample.py index 9000347edb..fb7fbc3930 100644 --- a/examples/org-website/custom_serializer_sample.py +++ b/examples/org-website/custom_serializer_sample.py @@ -10,10 +10,10 @@ def __init__(self, value=None): class CustomSerializer(StreamSerializer): def write(self, out, obj): - out.write_utf(obj.value) + out.write_string(obj.value) def read(self, inp): - return CustomSerializableType(inp.read_utf()) + return CustomSerializableType(inp.read_string()) def get_type_id(self): return 10 diff --git a/examples/org-website/executor_service_sample.py b/examples/org-website/executor_service_sample.py index d9d14aa7f7..6b0801ccc5 100644 --- a/examples/org-website/executor_service_sample.py +++ b/examples/org-website/executor_service_sample.py @@ -11,10 +11,10 @@ def __init__(self, message=None): self.message = message def write_portable(self, writer): - writer.write_utf("message", self.message) + writer.write_string("message", self.message) def read_portable(self, reader): - self.message = reader.read_utf("message") + self.message = reader.read_string("message") def get_factory_id(self): return self.FACTORY_ID diff --git a/examples/org-website/identified_data_serializable_sample.py b/examples/org-website/identified_data_serializable_sample.py index d8c811b9c3..ca2a4bd9c6 100644 --- a/examples/org-website/identified_data_serializable_sample.py +++ b/examples/org-website/identified_data_serializable_sample.py @@ -13,11 +13,11 @@ def __init__(self, id=None, name=None): def read_data(self, object_data_input): self.id = object_data_input.read_int() - self.name = object_data_input.read_utf() + self.name = object_data_input.read_string() def write_data(self, object_data_output): object_data_output.write_int(self.id) - object_data_output.write_utf(self.name) + object_data_output.write_string(self.name) def get_factory_id(self): return self.FACTORY_ID diff --git a/examples/org-website/portable_serializable_sample.py b/examples/org-website/portable_serializable_sample.py index 8e2915e6c7..779a41f43e 100644 --- a/examples/org-website/portable_serializable_sample.py +++ b/examples/org-website/portable_serializable_sample.py @@ -12,15 +12,15 @@ def __init__(self, id=None, name=None, last_order=None): self.name = name self.last_order = last_order - def read_portable(self, object_data_input): - self.id = object_data_input.read_int("id") - self.name = object_data_input.read_utf("name") - self.last_order = object_data_input.read_long("last_order") - - def write_portable(self, object_data_output): - object_data_output.write_int("id", self.id) - object_data_output.write_utf("name", self.name) - object_data_output.write_long("last_order", self.last_order) + def read_portable(self, reader): + self.id = reader.read_int("id") + self.name = reader.read_string("name") + self.last_order = reader.read_long("last_order") + + def write_portable(self, writer): + writer.write_int("id", self.id) + writer.write_string("name", self.name) + writer.write_long("last_order", self.last_order) def get_factory_id(self): return self.FACTORY_ID diff --git a/examples/org-website/query_sample.py b/examples/org-website/query_sample.py index 131e44625f..4ad91e8b89 100644 --- a/examples/org-website/query_sample.py +++ b/examples/org-website/query_sample.py @@ -14,12 +14,12 @@ def __init__(self, username=None, age=None, active=None): self.active = active def write_portable(self, writer): - writer.write_utf("username", self.username) + writer.write_string("username", self.username) writer.write_int("age", self.age) writer.write_boolean("active", self.active) def read_portable(self, reader): - self.username = reader.read_utf("username") + self.username = reader.read_string("username") self.age = reader.read_int("age") self.active = reader.read_boolean("active") diff --git a/examples/serialization/global_serialization_example.py b/examples/serialization/global_serialization_example.py index ba3a377b0b..5ff7b960d5 100644 --- a/examples/serialization/global_serialization_example.py +++ b/examples/serialization/global_serialization_example.py @@ -23,12 +23,12 @@ def __init__(self): super(GlobalSerializer, self).__init__() def read(self, inp): - utf = inp.read_utf() - obj = cPickle.loads(utf.encode()) + string = inp.read_string() + obj = cPickle.loads(string.encode()) return obj def write(self, out, obj): - out.write_utf(cPickle.dumps(obj, 0).decode("utf-8")) + out.write_string(cPickle.dumps(obj, 0).decode("utf-8")) def get_type_id(self): return self.GLOBAL_SERIALIZER_ID diff --git a/examples/serialization/identified_data_serializable_example.py b/examples/serialization/identified_data_serializable_example.py index 849253feac..222115e424 100644 --- a/examples/serialization/identified_data_serializable_example.py +++ b/examples/serialization/identified_data_serializable_example.py @@ -14,12 +14,12 @@ def __init__(self, id=None, name=None, gpa=None): def read_data(self, object_data_input): self.id = object_data_input.read_int() - self.name = object_data_input.read_utf() + self.name = object_data_input.read_string() self.gpa = object_data_input.read_float() def write_data(self, object_data_output): object_data_output.write_int(self.id) - object_data_output.write_utf(self.name) + object_data_output.write_string(self.name) object_data_output.write_float(self.gpa) def get_factory_id(self): diff --git a/examples/serialization/portable_example.py b/examples/serialization/portable_example.py index 7c7819086a..4b1f433ecc 100644 --- a/examples/serialization/portable_example.py +++ b/examples/serialization/portable_example.py @@ -13,14 +13,14 @@ def __init__(self, name=None, age=None, languages=None): self.languages = languages def read_portable(self, reader): - self.name = reader.read_utf("name") + self.name = reader.read_string("name") self.age = reader.read_int("age") - self.languages = reader.read_utf_array("languages") + self.languages = reader.read_string_array("languages") def write_portable(self, writer): - writer.write_utf("name", self.name) + writer.write_string("name", self.name) writer.write_int("age", self.age) - writer.write_utf_array("languages", self.languages) + writer.write_string_array("languages", self.languages) def get_factory_id(self): return self.FACTORY_ID diff --git a/hazelcast/predicate.py b/hazelcast/predicate.py index 3166e84dc6..104631f301 100644 --- a/hazelcast/predicate.py +++ b/hazelcast/predicate.py @@ -149,7 +149,7 @@ def __init__(self, expression=None): self.sql = expression def write_data(self, output): - output.write_utf(self.sql) + output.write_string(self.sql) def __repr__(self): return "SqlPredicate(sql='%s')" % self.sql @@ -179,7 +179,7 @@ def __init__(self, attribute, from_, to): self.to = to def write_data(self, output): - output.write_utf(self.attribute) + output.write_string(self.attribute) output.write_object(self.to) output.write_object(self.from_) @@ -199,7 +199,7 @@ def __init__(self, attribute, value): self.value = value def write_data(self, output): - output.write_utf(self.attribute) + output.write_string(self.attribute) output.write_object(self.value) def __repr__(self): @@ -216,7 +216,7 @@ def __init__(self, attribute, value, is_equal, is_less): self.is_less = is_less def write_data(self, output): - output.write_utf(self.attribute) + output.write_string(self.attribute) output.write_object(self.value) output.write_boolean(self.is_equal) output.write_boolean(self.is_less) @@ -238,8 +238,8 @@ def __init__(self, attribute, pattern): self.expression = pattern def write_data(self, output): - output.write_utf(self.attribute) - output.write_utf(self.expression) + output.write_string(self.attribute) + output.write_string(self.expression) def __repr__(self): return "LikePredicate(attribute='%s', expression='%s')" % (self.attribute, self.expression) @@ -260,7 +260,7 @@ def __init__(self, attribute, values): self.values = values def write_data(self, output): - output.write_utf(self.attribute) + output.write_string(self.attribute) output.write_int(len(self.values)) for value in self.values: output.write_object(value) @@ -279,7 +279,7 @@ def __init__(self, class_name): self.class_name = class_name def write_data(self, output): - output.write_utf(self.class_name) + output.write_string(self.class_name) def __repr__(self): return "InstanceOfPredicate(class_name='%s')" % self.class_name @@ -320,8 +320,8 @@ def __init__(self, attribute, pattern): self.pattern = pattern def write_data(self, output): - output.write_utf(self.attribute) - output.write_utf(self.pattern) + output.write_string(self.attribute) + output.write_string(self.pattern) def __repr__(self): return "RegexPredicate(attribute='%s', pattern='%s')" % (self.attribute, self.pattern) @@ -376,7 +376,7 @@ def write_data(self, output): output.write_object(self.comparator) output.write_int(self.page) output.write_int(self._page_size) - output.write_utf(get_attr_name(IterationType, self.iteration_type)) + output.write_string(get_attr_name(IterationType, self.iteration_type)) output.write_int(len(self.anchor_list)) for nearest_page, (anchor_key, anchor_value) in self.anchor_list: output.write_int(nearest_page) diff --git a/hazelcast/serialization/api.py b/hazelcast/serialization/api.py index 6eead8c1db..fe27ea9090 100644 --- a/hazelcast/serialization/api.py +++ b/hazelcast/serialization/api.py @@ -100,9 +100,21 @@ def write_chars(self, val): """ raise NotImplementedError() + def write_string(self, val): + """Writes UTF-8 string to this output stream. + + Args: + val (str): The UTF-8 string to be written. + """ + raise NotImplementedError() + def write_utf(self, val): """Writes UTF-8 string to this output stream. + .. deprecated:: 4.1 + This method is deprecated and will be removed in the + next major version. Use :func:`write_string` instead. + Args: val (str): The UTF-8 string to be written. """ @@ -172,9 +184,21 @@ def write_short_array(self, val): """ raise NotImplementedError() + def write_string_array(self, val): + """Writes a UTF-8 String array to this output stream. + + Args: + val (list[str]): The UTF-8 String array to be written. + """ + raise NotImplementedError() + def write_utf_array(self, val): """Writes a UTF-8 String array to this output stream. + .. deprecated:: 4.1 + This method is deprecated and will be removed in the + next major version. Use :func:`write_string_array` instead. + Args: val (list[str]): The UTF-8 String array to be written. """ @@ -314,9 +338,21 @@ def read_double(self): """ raise NotImplementedError() + def read_string(self): + """Reads a UTF-8 string from input stream and returns it. + + Returns: + str: The UTF-8 string read. + """ + raise NotImplementedError() + def read_utf(self): """Reads a UTF-8 string from input stream and returns it. + .. deprecated:: 4.1 + This method is deprecated and will be removed in the + next major version. Use :func:`read_string` instead. + Returns: str: The UTF-8 string read. """ @@ -386,9 +422,21 @@ def read_short_array(self): """ raise NotImplementedError() + def read_string_array(self): + """Reads a UTF-8 string array from input stream and returns it. + + Returns: + list[str]: The UTF-8 string array read. + """ + raise NotImplementedError() + def read_utf_array(self): """Reads a UTF-8 string array from input stream and returns it. + .. deprecated:: 4.1 + This method is deprecated and will be removed in the + next major version. Use :func:`read_string_array` instead. + Returns: list[str]: The UTF-8 string array read. """ @@ -634,9 +682,24 @@ def read_long(self, field_name): """ raise NotImplementedError() + def read_string(self, field_name): + """Reads a UTF-8 String. + + Args: + field_name (str): Name of the field. + + Returns: + str: The UTF-8 String read. + """ + raise NotImplementedError() + def read_utf(self, field_name): """Reads a UTF-8 String. + .. deprecated:: 4.1 + This method is deprecated and will be removed in the + next major version. Use :func:`read_string` instead. + Args: field_name (str): Name of the field. @@ -810,9 +873,24 @@ def read_short_array(self, field_name): """ raise NotImplementedError() + def read_string_array(self, field_name): + """Reads a UTF-8 String array. + + Args: + field_name (str): Name of the field. + + Returns: + str: The UTF-8 String array read. + """ + raise NotImplementedError() + def read_utf_array(self, field_name): """Reads a UTF-8 String array. + .. deprecated:: 4.1 + This method is deprecated and will be removed in the + next major version. Use :func:`read_string_array` instead. + Args: field_name (str): Name of the field. @@ -865,9 +943,22 @@ def write_long(self, field_name, value): """ raise NotImplementedError() + def write_string(self, field_name, value): + """Writes an UTF string. + + Args: + field_name (str): Name of the field. + value (str): UTF string value to be written. + """ + raise NotImplementedError() + def write_utf(self, field_name, value): """Writes an UTF string. + .. deprecated:: 4.1 + This method is deprecated and will be removed in the + next major version. Use :func:`write_string` instead. + Args: field_name (str): Name of the field. value (str): UTF string value to be written. @@ -1019,9 +1110,22 @@ def write_short_array(self, field_name, values): """ raise NotImplementedError() + def write_string_array(self, field_name, values): + """Writes a UTF-8 String array. + + Args: + field_name (str): Name of the field. + values: (str): UTF-8 String array to be written. + """ + raise NotImplementedError() + def write_utf_array(self, field_name, values): """Writes a UTF-8 String array. + .. deprecated:: 4.1 + This method is deprecated and will be removed in the + next major version. Use :func:`write_string_array` instead. + Args: field_name (str): Name of the field. values: (str): UTF-8 String array to be written. diff --git a/hazelcast/serialization/input.py b/hazelcast/serialization/input.py index a06d1424d2..284a831d53 100644 --- a/hazelcast/serialization/input.py +++ b/hazelcast/serialization/input.py @@ -84,7 +84,7 @@ def read_double(self, position=None): self._check_available(self._pos, DOUBLE_SIZE_IN_BYTES) return self._read_from_buff(self._FMT_DOUBLE, DOUBLE_SIZE_IN_BYTES, position) - def read_utf(self): + def read_string(self): length = self.read_int() if length == NULL_ARRAY_LENGTH: return None @@ -124,8 +124,8 @@ def read_float_array(self): def read_short_array(self): return self._read_array_fnc(self.read_short) - def read_utf_array(self): - return self._read_array_fnc(self.read_utf) + def read_string_array(self): + return self._read_array_fnc(self.read_string) def read_object(self): return self._service.read_object(self) @@ -147,6 +147,12 @@ def get_byte_order(self): return "BIG_ENDIAN" return "LITTLE_ENDIAN" + def read_utf(self): + return self.read_string() + + def read_utf_array(self): + return self.read_string_array() + # HELPERS def _check_available(self, position, size): _position = self._pos if position is None else position diff --git a/hazelcast/serialization/output.py b/hazelcast/serialization/output.py index 391e5eb362..978af3217c 100644 --- a/hazelcast/serialization/output.py +++ b/hazelcast/serialization/output.py @@ -77,7 +77,7 @@ def write_double(self, val): self._FMT_DOUBLE.pack_into(self._buffer, self._pos, val) self._pos += DOUBLE_SIZE_IN_BYTES - def write_utf(self, val): + def write_string(self, val): if val is None: self.write_int(NULL_ARRAY_LENGTH) else: @@ -124,8 +124,8 @@ def write_float_array(self, val): def write_short_array(self, val): self._write_array_fnc(val, self.write_short) - def write_utf_array(self, val): - self._write_array_fnc(val, self.write_utf) + def write_string_array(self, val): + self._write_array_fnc(val, self.write_string) def write_object(self, val): self._service.write_object(self, val) @@ -148,9 +148,15 @@ def set_position(self, position): self._pos = position def write_zero_bytes(self, count): - for i in range(0, count): + for _ in range(0, count): self._write(0) + def write_utf(self, val): + self.write_string(val) + + def write_utf_array(self, val): + self.write_string_array(val) + # HELPERS def _write_array_fnc(self, val, item_write_fnc): _len = len(val) if val is not None else NULL_ARRAY_LENGTH @@ -179,10 +185,10 @@ def __repr__(self): class EmptyObjectDataOutput(ObjectDataOutput): - def write_utf_array(self, val): + def write_string_array(self, val): pass - def write_utf(self, val): + def write_string(self, val): pass def write_short_array(self, val): @@ -250,3 +256,9 @@ def to_byte_array(self): def get_byte_order(self): pass + + def write_utf(self, val): + pass + + def write_utf_array(self, val): + pass diff --git a/hazelcast/serialization/portable/classdef.py b/hazelcast/serialization/portable/classdef.py index e532e8555a..8a9a812c26 100644 --- a/hazelcast/serialization/portable/classdef.py +++ b/hazelcast/serialization/portable/classdef.py @@ -12,7 +12,8 @@ class FieldType(object): LONG = 6 FLOAT = 7 DOUBLE = 8 - UTF = 9 + UTF = 9 # Defined for backwards compatibility. + STRING = 9 PORTABLE_ARRAY = 10 BYTE_ARRAY = 11 BOOLEAN_ARRAY = 12 @@ -22,7 +23,8 @@ class FieldType(object): LONG_ARRAY = 16 FLOAT_ARRAY = 17 DOUBLE_ARRAY = 18 - UTF_ARRAY = 19 + UTF_ARRAY = 19 # Defined for backwards compatibility. + STRING_ARRAY = 19 class FieldDefinition(object): @@ -183,10 +185,18 @@ def add_double_field(self, field_name): self._add_field_by_type(field_name, FieldType.DOUBLE, self.version) return self - def add_utf_field(self, field_name): - self._add_field_by_type(field_name, FieldType.UTF, self.version) + def add_string_field(self, field_name): + self._add_field_by_type(field_name, FieldType.STRING, self.version) return self + def add_utf_field(self, field_name): + """ + .. deprecated:: 4.1 + This method is deprecated and will be removed in the + next major version. Use :func:`add_string_field` instead. + """ + return self.add_string_field(field_name) + def add_portable_array_field(self, field_name, class_def): if class_def.class_id is None or class_def.class_id == 0: raise ValueError("Portable class id cannot be zero!") @@ -231,10 +241,18 @@ def add_double_array_field(self, field_name): self._add_field_by_type(field_name, FieldType.DOUBLE_ARRAY, self.version) return self - def add_utf_array_field(self, field_name): - self._add_field_by_type(field_name, FieldType.UTF_ARRAY, self.version) + def add_string_array_field(self, field_name): + self._add_field_by_type(field_name, FieldType.STRING_ARRAY, self.version) return self + def add_utf_array_field(self, field_name): + """ + .. deprecated:: 4.1 + This method is deprecated and will be removed in the + next major version. Use :func:`add_string_array_field` instead. + """ + return self.add_string_array_field(field_name) + def add_field_def(self, field_def): self._check() if self._index != field_def.index: diff --git a/hazelcast/serialization/portable/reader.py b/hazelcast/serialization/portable/reader.py index 79e34c6489..46b5d80567 100644 --- a/hazelcast/serialization/portable/reader.py +++ b/hazelcast/serialization/portable/reader.py @@ -71,12 +71,12 @@ def read_double(self, field_name): pos = self._read_position(field_name, FieldType.DOUBLE) return self._in.read_double(pos) - def read_utf(self, field_name): + def read_string(self, field_name): cur_pos = self._in.position() try: - pos = self._read_position(field_name, FieldType.UTF) + pos = self._read_position(field_name, FieldType.STRING) self._in.set_position(pos) - return self._in.read_utf() + return self._in.read_string() finally: self._in.set_position(cur_pos) @@ -177,12 +177,12 @@ def read_double_array(self, field_name): finally: self._in.set_position(current_pos) - def read_utf_array(self, field_name): + def read_string_array(self, field_name): current_pos = self._in.position() try: - pos = self._read_position(field_name, FieldType.UTF_ARRAY) + pos = self._read_position(field_name, FieldType.STRING_ARRAY) self._in.set_position(pos) - return self._in.read_utf_array() + return self._in.read_string_array() finally: self._in.set_position(current_pos) @@ -219,6 +219,12 @@ def read_portable_array(self, field_name): finally: self._in.set_position(current_pos) + def read_utf(self, field_name): + return self.read_string(field_name) + + def read_utf_array(self, field_name): + return self.read_string_array(field_name) + def get_raw_data_input(self): if not self._raw: pos = self._in.read_int( @@ -394,19 +400,19 @@ def read_char(self, field_name): self.validate_type_compatibility(fd, FieldType.CHAR) return super(MorphingPortableReader, self).read_char(field_name) - def read_utf(self, field_name): + def read_string(self, field_name): fd = self._class_def.get_field(field_name) if fd is None: return None - self.validate_type_compatibility(fd, FieldType.UTF) - return super(MorphingPortableReader, self).read_utf(field_name) + self.validate_type_compatibility(fd, FieldType.STRING) + return super(MorphingPortableReader, self).read_string(field_name) - def read_utf_array(self, field_name): + def read_string_array(self, field_name): fd = self._class_def.get_field(field_name) if fd is None: return None - self.validate_type_compatibility(fd, FieldType.UTF_ARRAY) - return super(MorphingPortableReader, self).read_utf_array(field_name) + self.validate_type_compatibility(fd, FieldType.STRING_ARRAY) + return super(MorphingPortableReader, self).read_string_array(field_name) def read_short_array(self, field_name): fd = self._class_def.get_field(field_name) @@ -478,6 +484,12 @@ def read_portable_array(self, field_name): self.validate_type_compatibility(fd, FieldType.PORTABLE_ARRAY) return super(MorphingPortableReader, self).read_portable_array(field_name) + def read_utf(self, field_name): + return self.read_string(field_name) + + def read_utf_array(self, field_name): + return self.read_string_array(field_name) + def validate_type_compatibility(self, field_def, expected_type): if field_def.field_type != expected_type: raise self.create_incompatible_class_change_error(field_def, expected_type) diff --git a/hazelcast/serialization/portable/writer.py b/hazelcast/serialization/portable/writer.py index 94429a9ca6..cf6f1b9ce6 100644 --- a/hazelcast/serialization/portable/writer.py +++ b/hazelcast/serialization/portable/writer.py @@ -57,9 +57,9 @@ def write_double(self, field_name, value): self._set_position(field_name, FieldType.DOUBLE) self._out.write_double(value) - def write_utf(self, field_name, value): - self._set_position(field_name, FieldType.UTF) - self._out.write_utf(value) + def write_string(self, field_name, value): + self._set_position(field_name, FieldType.STRING) + self._out.write_string(value) def write_byte_array(self, field_name, values): self._set_position(field_name, FieldType.BYTE_ARRAY) @@ -93,9 +93,9 @@ def write_double_array(self, field_name, values): self._set_position(field_name, FieldType.DOUBLE_ARRAY) self._out.write_double_array(values) - def write_utf_array(self, field_name, values): - self._set_position(field_name, FieldType.UTF_ARRAY) - self._out.write_utf_array(values) + def write_string_array(self, field_name, values): + self._set_position(field_name, FieldType.STRING_ARRAY) + self._out.write_string_array(values) def write_portable(self, field_name, portable): fd = self._set_position(field_name, FieldType.PORTABLE) @@ -140,6 +140,12 @@ def get_raw_data_output(self): self._raw = True return self._out + def write_utf(self, field_name, value): + self.write_string(field_name, value) + + def write_utf_array(self, field_name, values): + self.write_string_array(field_name, values) + # internal def _set_position(self, field_name, field_type): if self._raw: @@ -222,8 +228,8 @@ def write_float(self, field_name, value): def write_double(self, field_name, value): self._builder.add_double_field(field_name) - def write_utf(self, field_name, value): - self._builder.add_utf_field(field_name) + def write_string(self, field_name, value): + self._builder.add_string_field(field_name) def write_byte_array(self, field_name, values): self._builder.add_byte_array_field(field_name) @@ -249,8 +255,8 @@ def write_float_array(self, field_name, values): def write_double_array(self, field_name, values): self._builder.add_double_array_field(field_name) - def write_utf_array(self, field_name, values): - self._builder.add_utf_array_field(field_name) + def write_string_array(self, field_name, values): + self._builder.add_string_array_field(field_name) def write_portable(self, field_name, portable): if portable is None: @@ -295,6 +301,12 @@ def write_null_portable(self, field_name, factory_id, class_id): def get_raw_data_output(self): return EmptyObjectDataOutput() + def write_utf(self, field_name, value): + self.write_string(field_name, value) + + def write_utf_array(self, field_name, values): + self.write_string_array(field_name, values) + def _create_nested_class_def(self, portable, nested_builder): _writer = ClassDefinitionWriter(self.portable_context, class_def_builder=nested_builder) portable.write_portable(_writer) diff --git a/hazelcast/serialization/serializer.py b/hazelcast/serialization/serializer.py index 30f253c83b..5e50c5f33e 100644 --- a/hazelcast/serialization/serializer.py +++ b/hazelcast/serialization/serializer.py @@ -122,10 +122,10 @@ def get_type_id(self): class StringSerializer(BaseSerializer): def read(self, inp): - return inp.read_utf() + return inp.read_string() def write(self, out, obj): - out.write_utf(obj) + out.write_string(obj) def get_type_id(self): return CONSTANT_TYPE_STRING @@ -150,10 +150,10 @@ def get_type_id(self): class HazelcastJsonValueSerializer(BaseSerializer): def read(self, inp): - return HazelcastJsonValue(inp.read_utf()) + return HazelcastJsonValue(inp.read_string()) def write(self, out, obj): - out.write_utf(obj.to_string()) + out.write_string(obj.to_string()) def get_type_id(self): return JAVASCRIPT_JSON_SERIALIZATION_TYPE @@ -243,7 +243,7 @@ def get_type_id(self): class StringArraySerializer(BaseSerializer): def read(self, inp): - return inp.read_utf_array() + return inp.read_string_array() # "write(self, out, obj)" is never called so not implemented here @@ -301,7 +301,7 @@ def get_type_id(self): class JavaClassSerializer(BaseSerializer): def read(self, inp): - return inp.read_utf() + return inp.read_string() # "write(self, out, obj)" is never called so not implemented here @@ -341,11 +341,11 @@ def get_type_id(self): class PythonObjectSerializer(BaseSerializer): def read(self, inp): - str = inp.read_utf().encode() + str = inp.read_string().encode() return cPickle.loads(str) def write(self, out, obj): - out.write_utf(cPickle.dumps(obj, 0).decode("utf-8")) + out.write_string(cPickle.dumps(obj, 0).decode("utf-8")) def get_type_id(self): return PYTHON_TYPE_PICKLE diff --git a/tests/predicate_test.py b/tests/predicate_test.py index e2ab3032d7..b9b01cb8f4 100644 --- a/tests/predicate_test.py +++ b/tests/predicate_test.py @@ -311,11 +311,11 @@ def get_class_version(self): return 15 def write_portable(self, writer): - writer.write_utf("name", self.name) + writer.write_string("name", self.name) writer.write_portable("limb", self.limb) def read_portable(self, reader): - self.name = reader.read_utf("name") + self.name = reader.read_string("name") self.limb = reader.read_portable("limb") def __eq__(self, other): @@ -338,10 +338,10 @@ def get_class_version(self): return 2 def write_portable(self, writer): - writer.write_utf("name", self.name) + writer.write_string("name", self.name) def read_portable(self, reader): - self.name = reader.read_utf("name") + self.name = reader.read_string("name") def __eq__(self, other): return isinstance(other, self.__class__) and self.name == other.name diff --git a/tests/proxy/cp/atomic_reference_test.py b/tests/proxy/cp/atomic_reference_test.py index bbf2029c36..1fc8e3f5f0 100644 --- a/tests/proxy/cp/atomic_reference_test.py +++ b/tests/proxy/cp/atomic_reference_test.py @@ -14,7 +14,7 @@ def __init__(self, suffix): self.suffix = suffix def write_data(self, object_data_output): - object_data_output.write_utf(self.suffix) + object_data_output.write_string(self.suffix) def read_data(self, object_data_input): pass diff --git a/tests/proxy/executor_test.py b/tests/proxy/executor_test.py index d8bcdd9c4e..020eaa44fc 100644 --- a/tests/proxy/executor_test.py +++ b/tests/proxy/executor_test.py @@ -12,10 +12,10 @@ def __init__(self, message): self.message = message def write_data(self, object_data_output): - object_data_output.write_utf(self.message) + object_data_output.write_string(self.message) def read_data(self, object_data_input): - self.message = object_data_input.read_utf() + self.message = object_data_input.read_string() def get_factory_id(self): return 66 diff --git a/tests/proxy/map_test.py b/tests/proxy/map_test.py index 1dd20c7a80..6472ec6837 100644 --- a/tests/proxy/map_test.py +++ b/tests/proxy/map_test.py @@ -20,10 +20,10 @@ def __init__(self, value=None): self.value = value def write_data(self, object_data_output): - object_data_output.write_utf(self.value) + object_data_output.write_string(self.value) def read_data(self, object_data_input): - self.value = object_data_input.read() + self.value = object_data_input.read_string() def get_factory_id(self): return self.FACTORY_ID diff --git a/tests/serialization/binary_compatibility/reference_objects.py b/tests/serialization/binary_compatibility/reference_objects.py index 7fa637f7d8..bad5503c34 100644 --- a/tests/serialization/binary_compatibility/reference_objects.py +++ b/tests/serialization/binary_compatibility/reference_objects.py @@ -209,7 +209,7 @@ def write_data(self, out): out.write_float(self.f) out.write_int(self.i) out.write_long(self.l) - out.write_utf(self.string) + out.write_string(self.string) out.write_boolean_array(self.booleans) out.write_byte_array(self.bytes_) @@ -219,7 +219,7 @@ def write_data(self, out): out.write_float_array(self.floats) out.write_int_array(self.ints) out.write_long_array(self.longs) - out.write_utf_array(self.strings) + out.write_string_array(self.strings) out.write_boolean_array(self.booleans_none) out.write_byte_array(self.bytes_none) @@ -229,7 +229,7 @@ def write_data(self, out): out.write_float_array(self.floats_none) out.write_int_array(self.ints_none) out.write_long_array(self.longs_none) - out.write_utf_array(self.strings_none) + out.write_string_array(self.strings_none) self.bytes_size = len(self.bytes_) out.write_byte(self.bytes_size) @@ -258,7 +258,7 @@ def read_data(self, inp): self.f = inp.read_float() self.i = inp.read_int() self.l = inp.read_long() - self.string = inp.read_utf() + self.string = inp.read_string() self.booleans = inp.read_boolean_array() self.bytes_ = inp.read_byte_array() @@ -268,7 +268,7 @@ def read_data(self, inp): self.floats = inp.read_float_array() self.ints = inp.read_int_array() self.longs = inp.read_long_array() - self.strings = inp.read_utf_array() + self.strings = inp.read_string_array() self.booleans_none = inp.read_boolean_array() self.bytes_none = inp.read_byte_array() @@ -278,7 +278,7 @@ def read_data(self, inp): self.floats_none = inp.read_float_array() self.ints_none = inp.read_int_array() self.longs_none = inp.read_long_array() - self.strings_none = inp.read_utf_array() + self.strings_none = inp.read_string_array() self.bytes_size = inp.read_byte() self.bytes_fully = bytearray(self.bytes_size) @@ -434,7 +434,7 @@ def write_portable(self, writer): writer.write_float("f", self.f) writer.write_int("i", self.i) writer.write_long("l", self.l) - writer.write_utf("str", self.string) + writer.write_string("str", self.string) if self.p: writer.write_portable("p", self.p) else: @@ -448,7 +448,7 @@ def write_portable(self, writer): writer.write_float_array("fs", self.floats) writer.write_int_array("is", self.ints) writer.write_long_array("ls", self.longs) - writer.write_utf_array("strs", self.strings) + writer.write_string_array("strs", self.strings) writer.write_portable_array("ps", self.portables) writer.write_boolean_array("booleansNull", self.booleans_none) @@ -459,7 +459,7 @@ def write_portable(self, writer): writer.write_float_array("fsNull", self.floats_none) writer.write_int_array("isNull", self.ints_none) writer.write_long_array("lsNull", self.longs_none) - writer.write_utf_array("strsNull", self.strings_none) + writer.write_string_array("strsNull", self.strings_none) out = writer.get_raw_data_output() @@ -471,7 +471,7 @@ def write_portable(self, writer): out.write_float(self.f) out.write_int(self.i) out.write_long(self.l) - out.write_utf(self.string) + out.write_string(self.string) out.write_boolean_array(self.booleans) out.write_byte_array(self.bytes_) @@ -481,7 +481,7 @@ def write_portable(self, writer): out.write_float_array(self.floats) out.write_int_array(self.ints) out.write_long_array(self.longs) - out.write_utf_array(self.strings) + out.write_string_array(self.strings) out.write_boolean_array(self.booleans_none) out.write_byte_array(self.bytes_none) @@ -491,7 +491,7 @@ def write_portable(self, writer): out.write_float_array(self.floats_none) out.write_int_array(self.ints_none) out.write_long_array(self.longs_none) - out.write_utf_array(self.strings_none) + out.write_string_array(self.strings_none) self.bytes_size = len(self.bytes_) out.write_byte(self.bytes_size) @@ -520,7 +520,7 @@ def read_portable(self, reader): self.f = reader.read_float("f") self.i = reader.read_int("i") self.l = reader.read_long("l") - self.string = reader.read_utf("str") + self.string = reader.read_string("str") self.p = reader.read_portable("p") self.booleans = reader.read_boolean_array("booleans") @@ -531,7 +531,7 @@ def read_portable(self, reader): self.floats = reader.read_float_array("fs") self.ints = reader.read_int_array("is") self.longs = reader.read_long_array("ls") - self.strings = reader.read_utf_array("strs") + self.strings = reader.read_string_array("strs") self.portables = reader.read_portable_array("ps") self.booleans_none = reader.read_boolean_array("booleansNull") @@ -542,7 +542,7 @@ def read_portable(self, reader): self.floats_none = reader.read_float_array("fsNull") self.ints_none = reader.read_int_array("isNull") self.longs_none = reader.read_long_array("lsNull") - self.strings_none = reader.read_utf_array("strsNull") + self.strings_none = reader.read_string_array("strsNull") inp = reader.get_raw_data_input() @@ -554,7 +554,7 @@ def read_portable(self, reader): self.f = inp.read_float() self.i = inp.read_int() self.l = inp.read_long() - self.string = inp.read_utf() + self.string = inp.read_string() self.booleans = inp.read_boolean_array() self.bytes_ = inp.read_byte_array() @@ -564,7 +564,7 @@ def read_portable(self, reader): self.floats = inp.read_float_array() self.ints = inp.read_int_array() self.longs = inp.read_long_array() - self.strings = inp.read_utf_array() + self.strings = inp.read_string_array() self.booleans_none = inp.read_boolean_array() self.bytes_none = inp.read_byte_array() @@ -574,7 +574,7 @@ def read_portable(self, reader): self.floats_none = inp.read_float_array() self.ints_none = inp.read_int_array() self.longs_none = inp.read_long_array() - self.strings_none = inp.read_utf_array() + self.strings_none = inp.read_string_array() self.bytes_size = inp.read_byte() self.bytes_fully = bytearray(self.bytes_size) diff --git a/tests/serialization/custom_global_serialization_test.py b/tests/serialization/custom_global_serialization_test.py index faf5f119af..ef66258c7a 100644 --- a/tests/serialization/custom_global_serialization_test.py +++ b/tests/serialization/custom_global_serialization_test.py @@ -11,8 +11,8 @@ def __init__(self): super(TestGlobalSerializer, self).__init__() def read(self, inp): - utf = inp.read_utf() - obj = cPickle.loads(utf.encode()) + string = inp.read_string() + obj = cPickle.loads(string.encode()) try: obj.source = "GLOBAL" except AttributeError: @@ -20,7 +20,7 @@ def read(self, inp): return obj def write(self, out, obj): - out.write_utf(cPickle.dumps(obj, 0).decode("utf-8")) + out.write_string(cPickle.dumps(obj, 0).decode("utf-8")) def get_type_id(self): return 10000 @@ -45,14 +45,14 @@ def __eq__(self, other): class CustomSerializer(StreamSerializer): def write(self, out, obj): if isinstance(obj, CustomClass): - out.write_utf(obj.uid) - out.write_utf(obj.name) - out.write_utf(obj.text) + out.write_string(obj.uid) + out.write_string(obj.name) + out.write_string(obj.text) else: raise ValueError("Can only serialize CustomClass") def read(self, inp): - return CustomClass(inp.read_utf(), inp.read_utf(), inp.read_utf(), "CUSTOM") + return CustomClass(inp.read_string(), inp.read_string(), inp.read_string(), "CUSTOM") def get_type_id(self): return 10001 @@ -64,16 +64,16 @@ def destroy(self): class TheOtherCustomSerializer(StreamSerializer): def write(self, out, obj): if isinstance(obj, CustomClass): - out.write_utf(obj.text) - out.write_utf(obj.name) - out.write_utf(obj.uid) + out.write_string(obj.text) + out.write_string(obj.name) + out.write_string(obj.uid) else: raise ValueError("Can only serialize CustomClass") def read(self, inp): - text_ = inp.read_utf() - name_ = inp.read_utf() - uid = inp.read_utf() + text_ = inp.read_string() + name_ = inp.read_string() + uid = inp.read_string() return CustomClass(uid, name_, text_, "CUSTOM") def get_type_id(self): diff --git a/tests/serialization/identified_test.py b/tests/serialization/identified_test.py index 5fffa3d267..bf86f24df1 100644 --- a/tests/serialization/identified_test.py +++ b/tests/serialization/identified_test.py @@ -68,8 +68,8 @@ def write_data(self, out): out.write_long_array(self.longs) out.write_float_array(self.floats) out.write_double_array(self.doubles) - out.write_utf(self.a_string) - out.write_utf_array(self.strings) + out.write_string(self.a_string) + out.write_string_array(self.strings) def read_data(self, inp): self.a_byte = inp.read_byte() @@ -89,8 +89,8 @@ def read_data(self, inp): self.longs = inp.read_long_array() self.floats = inp.read_float_array() self.doubles = inp.read_double_array() - self.a_string = inp.read_utf() - self.strings = inp.read_utf_array() + self.a_string = inp.read_string() + self.strings = inp.read_string_array() def get_factory_id(self): return FACTORY_ID diff --git a/tests/serialization/morphing_portable_test.py b/tests/serialization/morphing_portable_test.py index 79598a1e20..dbb3985d83 100644 --- a/tests/serialization/morphing_portable_test.py +++ b/tests/serialization/morphing_portable_test.py @@ -177,7 +177,7 @@ def test_incompatible_types(self): self.reader.read_long, self.reader.read_float, self.reader.read_double, - self.reader.read_utf_array, + self.reader.read_string_array, self.reader.read_short_array, self.reader.read_int_array, self.reader.read_long_array, @@ -193,12 +193,12 @@ def test_incompatible_types(self): with self.assertRaises(TypeError): read_fnc("9") with self.assertRaises(TypeError): - self.reader.read_utf("1") + self.reader.read_string("1") def test_missing_fields(self): functions = [ - self.reader.read_utf, - self.reader.read_utf_array, + self.reader.read_string, + self.reader.read_string_array, self.reader.read_short_array, self.reader.read_int_array, self.reader.read_long_array, diff --git a/tests/serialization/portable_test.py b/tests/serialization/portable_test.py index dbcb96e9c2..4c38b4a4e4 100644 --- a/tests/serialization/portable_test.py +++ b/tests/serialization/portable_test.py @@ -73,7 +73,7 @@ def write_portable(self, out): out.write_long("6", self.a_long) out.write_float("7", self.a_float) out.write_double("8", self.a_double) - out.write_utf("9", self.a_string) + out.write_string("9", self.a_string) out.write_byte_array("a1", self.bytes) out.write_boolean_array("a2", self.booleans) @@ -83,7 +83,7 @@ def write_portable(self, out): out.write_long_array("a6", self.longs) out.write_float_array("a7", self.floats) out.write_double_array("a8", self.doubles) - out.write_utf_array("a9", self.strings) + out.write_string_array("a9", self.strings) if self.inner_portable is None: out.write_null_portable("p", FACTORY_ID, InnerPortable.CLASS_ID) @@ -108,7 +108,7 @@ def read_portable(self, inp): self.a_long = inp.read_long("6") self.a_float = inp.read_float("7") self.a_double = inp.read_double("8") - self.a_string = inp.read_utf("9") + self.a_string = inp.read_string("9") self.bytes = inp.read_byte_array("a1") self.booleans = inp.read_boolean_array("a2") @@ -118,7 +118,7 @@ def read_portable(self, inp): self.longs = inp.read_long_array("a6") self.floats = inp.read_float_array("a7") self.doubles = inp.read_double_array("a8") - self.strings = inp.read_utf_array("a9") + self.strings = inp.read_string_array("a9") self.inner_portable = inp.read_portable("p") @@ -195,11 +195,11 @@ def __init__(self, param_str=None, param_int=None): self.param_int = param_int def write_portable(self, writer): - writer.write_utf("param_str", self.param_str) + writer.write_string("param_str", self.param_str) writer.write_int("param_int", self.param_int) def read_portable(self, reader): - self.param_str = reader.read_utf("param_str") + self.param_str = reader.read_string("param_str") self.param_int = reader.read_int("param_int") def get_factory_id(self): @@ -246,10 +246,10 @@ def get_class_id(self): return 2 def write_portable(self, writer): - writer.write_utf("name", self.name) + writer.write_string("name", self.name) def read_portable(self, reader): - self.name = reader.read_utf("name") + self.name = reader.read_string("name") def __eq__(self, other): return isinstance(other, self.__class__) and self.name == other.name @@ -295,10 +295,10 @@ def __init__(self, str_field=None): self.str_field = str_field def write_portable(self, writer): - writer.write_utf("str_field", self.str_field) + writer.write_string("str_field", self.str_field) def read_portable(self, reader): - self.str_field = reader.read_utf("str_field") + self.str_field = reader.read_string("str_field") def get_factory_id(self): return 1 @@ -390,7 +390,7 @@ def test_portable_null_fields(self): def test_portable_class_def(self): builder_inner = ClassDefinitionBuilder(FACTORY_ID, InnerPortable.CLASS_ID) - builder_inner.add_utf_field("param_str") + builder_inner.add_string_field("param_str") builder_inner.add_int_field("param_int") class_def_inner = builder_inner.build() @@ -404,7 +404,7 @@ def test_portable_class_def(self): builder.add_long_field("6") builder.add_float_field("7") builder.add_double_field("8") - builder.add_utf_field("9") + builder.add_string_field("9") builder.add_byte_array_field("a1") builder.add_boolean_array_field("a2") builder.add_char_array_field("a3") @@ -413,7 +413,7 @@ def test_portable_class_def(self): builder.add_long_array_field("a6") builder.add_float_array_field("a7") builder.add_double_array_field("a8") - builder.add_utf_array_field("a9") + builder.add_string_array_field("a9") builder.add_portable_field("p", class_def_inner) builder.add_portable_array_field("ap", class_def_inner) class_def = builder.build() @@ -471,7 +471,7 @@ def test_nested_null_portable_serialization(self): config.portable_factories = {1: {1: Parent, 2: Child}} - child_class_def = ClassDefinitionBuilder(FACTORY_ID, 2).add_utf_field("name").build() + child_class_def = ClassDefinitionBuilder(FACTORY_ID, 2).add_string_field("name").build() parent_class_def = ( ClassDefinitionBuilder(FACTORY_ID, 1) .add_portable_field("child", child_class_def) @@ -490,7 +490,7 @@ def test_nested_null_portable_serialization(self): def test_duplicate_class_definition(self): config = _Config() - class_def1 = ClassDefinitionBuilder(1, 1).add_utf_field("str_field").build() + class_def1 = ClassDefinitionBuilder(1, 1).add_string_field("str_field").build() class_def2 = ClassDefinitionBuilder(1, 1).add_int_field("int_field").build() config.class_definitions = [class_def1, class_def2] @@ -502,7 +502,7 @@ def test_classes_with_same_class_id_in_different_factories(self): config = _Config() config.portable_factories = {1: {1: MyPortable1}, 2: {1: MyPortable2}} - class_def1 = ClassDefinitionBuilder(1, 1).add_utf_field("str_field").build() + class_def1 = ClassDefinitionBuilder(1, 1).add_string_field("str_field").build() class_def2 = ClassDefinitionBuilder(2, 1).add_int_field("int_field").build() config.class_definitions = [class_def1, class_def2] diff --git a/tests/soak_test/map_soak_test.py b/tests/soak_test/map_soak_test.py index 20de91d066..2d39a5786a 100644 --- a/tests/soak_test/map_soak_test.py +++ b/tests/soak_test/map_soak_test.py @@ -47,7 +47,7 @@ def read_data(self, object_data_input): pass def write_data(self, object_data_output): - object_data_output.write_utf(self.value) + object_data_output.write_string(self.value) def get_class_id(self): return self.CLASS_ID