INSTRUCTION stringlengths 1 46.3k | RESPONSE stringlengths 75 80.2k |
|---|---|
Closes the connection with given address.
:param address: (:class:`~hazelcast.core.Address`), address of the connection to be closed.
:param cause: (Exception), the cause for closing the connection.
:return: (bool), ``true`` if the connection is closed, ``false`` otherwise. | def close_connection(self, address, cause):
"""
Closes the connection with given address.
:param address: (:class:`~hazelcast.core.Address`), address of the connection to be closed.
:param cause: (Exception), the cause for closing the connection.
:return: (bool), ``true`` if the... |
Starts sending periodic HeartBeat operations. | def start(self):
"""
Starts sending periodic HeartBeat operations.
"""
def _heartbeat():
if not self._client.lifecycle.is_live:
return
self._heartbeat()
self._heartbeat_timer = self._client.reactor.add_timer(self._heartbeat_interval, _h... |
Sends a message to this connection.
:param message: (Message), message to be sent to this connection. | def send_message(self, message):
"""
Sends a message to this connection.
:param message: (Message), message to be sent to this connection.
"""
if not self.live():
raise IOError("Connection is not live.")
message.add_flag(BEGIN_END_FLAG)
self.write(me... |
Receives a message from this connection. | def receive_message(self):
"""
Receives a message from this connection.
"""
# split frames
while len(self._read_buffer) >= INT_SIZE_IN_BYTES:
frame_length = struct.unpack_from(FMT_LE_INT, self._read_buffer, 0)[0]
if frame_length > len(self._read_buffer):
... |
Transactional implementation of :func:`Set.add(item) <hazelcast.proxy.set.Set.add>`
:param item: (object), the new item to be added.
:return: (bool), ``true`` if item is added successfully, ``false`` otherwise. | def add(self, item):
"""
Transactional implementation of :func:`Set.add(item) <hazelcast.proxy.set.Set.add>`
:param item: (object), the new item to be added.
:return: (bool), ``true`` if item is added successfully, ``false`` otherwise.
"""
check_not_none(item, "item can'... |
Transactional implementation of :func:`Set.remove(item) <hazelcast.proxy.set.Set.remove>`
:param item: (object), the specified item to be deleted.
:return: (bool), ``true`` if item is remove successfully, ``false`` otherwise. | def remove(self, item):
"""
Transactional implementation of :func:`Set.remove(item) <hazelcast.proxy.set.Set.remove>`
:param item: (object), the specified item to be deleted.
:return: (bool), ``true`` if item is remove successfully, ``false`` otherwise.
"""
check_not_non... |
Calculates the request payload size | def calculate_size(name, attribute, ordered):
""" Calculates the request payload size"""
data_size = 0
data_size += calculate_size_str(name)
data_size += calculate_size_str(attribute)
data_size += BOOLEAN_SIZE_IN_BYTES
return data_size |
Encode request into client_message | def encode_request(name, attribute, ordered):
""" Encode request into client_message"""
client_message = ClientMessage(payload_size=calculate_size(name, attribute, ordered))
client_message.set_message_type(REQUEST_TYPE)
client_message.set_retryable(RETRYABLE)
client_message.append_str(name)
clie... |
Calculates the request payload size | def calculate_size(name, sequence):
""" Calculates the request payload size"""
data_size = 0
data_size += calculate_size_str(name)
data_size += LONG_SIZE_IN_BYTES
return data_size |
Calculates the request payload size | def calculate_size(name, count):
""" Calculates the request payload size"""
data_size = 0
data_size += calculate_size_str(name)
data_size += INT_SIZE_IN_BYTES
return data_size |
Try to initialize this Semaphore instance with the given permit count.
:param permits: (int), the given permit count.
:return: (bool), ``true`` if initialization success. | def init(self, permits):
"""
Try to initialize this Semaphore instance with the given permit count.
:param permits: (int), the given permit count.
:return: (bool), ``true`` if initialization success.
"""
check_not_negative(permits, "Permits cannot be negative!")
... |
Acquires one or specified amount of permits if available, and returns immediately, reducing the number of
available permits by one or given amount.
If insufficient permits are available then the current thread becomes disabled for thread scheduling purposes
and lies dormant until one of followi... | def acquire(self, permits=1):
"""
Acquires one or specified amount of permits if available, and returns immediately, reducing the number of
available permits by one or given amount.
If insufficient permits are available then the current thread becomes disabled for thread scheduling purp... |
Shrinks the number of available permits by the indicated reduction. This method differs from acquire in that it
does not block waiting for permits to become available.
:param reduction: (int), the number of permits to remove. | def reduce_permits(self, reduction):
"""
Shrinks the number of available permits by the indicated reduction. This method differs from acquire in that it
does not block waiting for permits to become available.
:param reduction: (int), the number of permits to remove.
"""
... |
Releases one or given number of permits, increasing the number of available permits by one or that amount.
There is no requirement that a thread that releases a permit must have acquired that permit by calling one of
the acquire methods. Correct usage of a semaphore is established by programming conven... | def release(self, permits=1):
"""
Releases one or given number of permits, increasing the number of available permits by one or that amount.
There is no requirement that a thread that releases a permit must have acquired that permit by calling one of
the acquire methods. Correct usage o... |
Tries to acquire one or the given number of permits, if they are available, and returns immediately, with the
value ``true``, reducing the number of available permits by the given amount.
If there are insufficient permits and a timeout is provided, the current thread becomes disabled for thread
... | def try_acquire(self, permits=1, timeout=0):
"""
Tries to acquire one or the given number of permits, if they are available, and returns immediately, with the
value ``true``, reducing the number of available permits by the given amount.
If there are insufficient permits and a timeout is... |
Event handler | def handle(client_message, handle_event_topic=None, to_object=None):
""" Event handler """
message_type = client_message.get_message_type()
if message_type == EVENT_TOPIC and handle_event_topic is not None:
item = client_message.read_data()
publish_time = client_message.read_long()
u... |
Calculates the request payload size | def calculate_size(name, entry_processor, keys):
""" Calculates the request payload size"""
data_size = 0
data_size += calculate_size_str(name)
data_size += calculate_size_data(entry_processor)
data_size += INT_SIZE_IN_BYTES
for keys_item in keys:
data_size += calculate_size_data(keys_it... |
Encode request into client_message | def encode_request(name, entry_processor, keys):
""" Encode request into client_message"""
client_message = ClientMessage(payload_size=calculate_size(name, entry_processor, keys))
client_message.set_message_type(REQUEST_TYPE)
client_message.set_retryable(RETRYABLE)
client_message.append_str(name)
... |
Calculates the request payload size | def calculate_size(username, password, uuid, owner_uuid, is_owner_connection, client_type, serialization_version, client_hazelcast_version):
""" Calculates the request payload size"""
data_size = 0
data_size += calculate_size_str(username)
data_size += calculate_size_str(password)
data_size += BOOLE... |
Encode request into client_message | def encode_request(username, password, uuid, owner_uuid, is_owner_connection, client_type, serialization_version, client_hazelcast_version):
""" Encode request into client_message"""
client_message = ClientMessage(payload_size=calculate_size(username, password, uuid, owner_uuid, is_owner_connection, client_type... |
Decode response from client message | def decode_response(client_message, to_object=None):
""" Decode response from client message"""
parameters = dict(status=None, address=None, uuid=None, owner_uuid=None, serialization_version=None, server_hazelcast_version=None, client_unregistered_members=None)
parameters['status'] = client_message.read_byt... |
Helper method for adding membership listeners
:param member_added: (Function), Function to be called when a member is added, in the form of f(member)
(optional).
:param member_removed: (Function), Function to be called when a member is removed, in the form of f(member)
(optional).
... | def add_membership_listener(self, member_added=None, member_removed=None, fire_for_existing=False):
"""
Helper method for adding membership listeners
:param member_added: (Function), Function to be called when a member is added, in the form of f(member)
(optional).
:param member... |
Assign a serializer for the type.
:param _type: (Type), the target type of the serializer
:param serializer: (Serializer), Custom Serializer constructor function | def set_custom_serializer(self, _type, serializer):
"""
Assign a serializer for the type.
:param _type: (Type), the target type of the serializer
:param serializer: (Serializer), Custom Serializer constructor function
"""
validate_type(_type)
validate_serializer(... |
Gets the value of the given property. First checks client config properties, then environment variables
and lastly fall backs to the default value of the property.
:param property: (:class:`~hazelcast.config.ClientProperty`), Property to get value from
:return: Value of the given property | def get(self, property):
"""
Gets the value of the given property. First checks client config properties, then environment variables
and lastly fall backs to the default value of the property.
:param property: (:class:`~hazelcast.config.ClientProperty`), Property to get value from
... |
Gets the value of the given property as boolean.
:param property: (:class:`~hazelcast.config.ClientProperty`), Property to get value from
:return: (bool), Value of the given property | def get_bool(self, property):
"""
Gets the value of the given property as boolean.
:param property: (:class:`~hazelcast.config.ClientProperty`), Property to get value from
:return: (bool), Value of the given property
"""
value = self.get(property)
if isinstance(v... |
Gets the value of the given property in seconds. If the value of the given property is not a number,
throws TypeError.
:param property: (:class:`~hazelcast.config.ClientProperty`), Property to get seconds from
:return: (float), Value of the given property in seconds | def get_seconds(self, property):
"""
Gets the value of the given property in seconds. If the value of the given property is not a number,
throws TypeError.
:param property: (:class:`~hazelcast.config.ClientProperty`), Property to get seconds from
:return: (float), Value of the g... |
Gets the value of the given property in seconds. If the value of the given property is not a number,
throws TypeError. If the value of the given property in seconds is not positive, tries to
return the default value in seconds.
:param property: (:class:`~hazelcast.config.ClientProperty`), Prope... | def get_seconds_positive_or_default(self, property):
"""
Gets the value of the given property in seconds. If the value of the given property is not a number,
throws TypeError. If the value of the given property in seconds is not positive, tries to
return the default value in seconds.
... |
Calculates the request payload size | def calculate_size(credentials, uuid, owner_uuid, is_owner_connection, client_type, serialization_version, client_hazelcast_version):
""" Calculates the request payload size"""
data_size = 0
data_size += calculate_size_data(credentials)
data_size += BOOLEAN_SIZE_IN_BYTES
if uuid is not None:
... |
Calculates the request payload size | def calculate_size(name, replica_timestamps, target_replica):
""" Calculates the request payload size"""
data_size = 0
data_size += calculate_size_str(name)
data_size += INT_SIZE_IN_BYTES
for replica_timestamps_item in replica_timestamps:
key = replica_timestamps_item[0]
val = replic... |
Encode request into client_message | def encode_request(name, replica_timestamps, target_replica):
""" Encode request into client_message"""
client_message = ClientMessage(payload_size=calculate_size(name, replica_timestamps, target_replica))
client_message.set_message_type(REQUEST_TYPE)
client_message.set_retryable(RETRYABLE)
client_m... |
Decode response from client message | def decode_response(client_message, to_object=None):
""" Decode response from client message"""
parameters = dict(value=None, replica_timestamps=None, replica_count=None)
parameters['value'] = client_message.read_long()
replica_timestamps_size = client_message.read_int()
replica_timestamps = []
... |
Calculates the request payload size | def calculate_size(name, value):
""" Calculates the request payload size"""
data_size = 0
data_size += calculate_size_str(name)
data_size += calculate_size_data(value)
return data_size |
Adds a continuous entry listener for this map. Listener will get notified for map events filtered with given
parameters.
:param key: (object), key for filtering the events (optional).
:param predicate: (Predicate), predicate for filtering the events (optional).
:param added_func: Functi... | def add_entry_listener(self, key=None, predicate=None, added_func=None, removed_func=None, updated_func=None,
evicted_func=None, clear_all_func=None):
"""
Adds a continuous entry listener for this map. Listener will get notified for map events filtered with given
param... |
Determines whether this map contains an entry with the key.
**Warning: This method uses __hash__ and __eq__ methods of binary form of the key, not the actual implementations
of __hash__ and __eq__ defined in key's class.**
:param key: (object), the specified key.
:return: (bool), ``tru... | def contains_key(self, key):
"""
Determines whether this map contains an entry with the key.
**Warning: This method uses __hash__ and __eq__ methods of binary form of the key, not the actual implementations
of __hash__ and __eq__ defined in key's class.**
:param key: (object), ... |
Determines whether this map contains one or more keys for the specified value.
:param value: (object), the specified value.
:return: (bool), ``true`` if this map contains an entry for the specified value. | def contains_value(self, value):
"""
Determines whether this map contains one or more keys for the specified value.
:param value: (object), the specified value.
:return: (bool), ``true`` if this map contains an entry for the specified value.
"""
check_not_none(value, "va... |
Returns the value for the specified key, or None if this map does not contain this key.
**Warning:
This method uses hashCode and equals of the binary form of the key, not the actual implementations of hashCode
and equals defined in the key's class.**
:param key: (object), the specified... | def get(self, key):
"""
Returns the value for the specified key, or None if this map does not contain this key.
**Warning:
This method uses hashCode and equals of the binary form of the key, not the actual implementations of hashCode
and equals defined in the key's class.**
... |
Associates the specified value with the specified key in this map. If the map previously contained a mapping for
the key, the old value is replaced by the specified value. If ttl is provided, entry will expire and get evicted
after the ttl.
:param key: (object), the specified key.
:para... | def put(self, key, value, ttl=0):
"""
Associates the specified value with the specified key in this map. If the map previously contained a mapping for
the key, the old value is replaced by the specified value. If ttl is provided, entry will expire and get evicted
after the ttl.
... |
Copies all of the mappings from the specified map to this map. No atomicity guarantees are
given. In the case of a failure, some of the key-value tuples may get written, while others are not.
:param map: (dict), map which includes mappings to be stored in this map. | def put_all(self, map):
"""
Copies all of the mappings from the specified map to this map. No atomicity guarantees are
given. In the case of a failure, some of the key-value tuples may get written, while others are not.
:param map: (dict), map which includes mappings to be stored in thi... |
Removes the mapping for a key from this map if it is present. The map will not contain a mapping for the
specified key once the call returns.
**Warning: This method uses __hash__ and __eq__ methods of binary form of the key, not the actual implementations
of __hash__ and __eq__ defined in key's... | def remove(self, key):
"""
Removes the mapping for a key from this map if it is present. The map will not contain a mapping for the
specified key once the call returns.
**Warning: This method uses __hash__ and __eq__ methods of binary form of the key, not the actual implementations
... |
Removes the specified entry listener. Returns silently if there is no such listener added before.
:param registration_id: (str), id of registered listener.
:return: (bool), ``true`` if registration is removed, ``false`` otherwise. | def remove_entry_listener(self, registration_id):
"""
Removes the specified entry listener. Returns silently if there is no such listener added before.
:param registration_id: (str), id of registered listener.
:return: (bool), ``true`` if registration is removed, ``false`` otherwise.
... |
Calculates the request payload size | def calculate_size(name, timeout):
""" Calculates the request payload size"""
data_size = 0
data_size += calculate_size_str(name)
data_size += LONG_SIZE_IN_BYTES
return data_size |
Starts the partition service. | def start(self):
"""
Starts the partition service.
"""
self.logger.debug("Starting partition service", extra=self._logger_extras)
def partition_updater():
self._do_refresh()
self.timer = self._client.reactor.add_timer(PARTITION_UPDATE_INTERVAL, partition_... |
Gets the owner of the partition if it's set. Otherwise it will trigger partition assignment.
:param partition_id: (int), the partition id.
:return: (:class:`~hazelcast.core.Address`), owner of partition or ``None`` if it's not set yet. | def get_partition_owner(self, partition_id):
"""
Gets the owner of the partition if it's set. Otherwise it will trigger partition assignment.
:param partition_id: (int), the partition id.
:return: (:class:`~hazelcast.core.Address`), owner of partition or ``None`` if it's not set yet.
... |
Returns the partition id for a Data key.
:param key: (object), the data key.
:return: (int), the partition id. | def get_partition_id(self, key):
"""
Returns the partition id for a Data key.
:param key: (object), the data key.
:return: (int), the partition id.
"""
data = self._client.serialization_service.to_data(key)
count = self.get_partition_count()
if count <= 0... |
murmur3 hash function to determine partition
:param data: (byte array), input byte array
:param offset: (long), offset.
:param size: (long), byte length.
:param seed: murmur hash seed hazelcast uses 0x01000193
:return: (int32), calculated hash value. | def murmur_hash3_x86_32(data, offset, size, seed=0x01000193):
"""
murmur3 hash function to determine partition
:param data: (byte array), input byte array
:param offset: (long), offset.
:param size: (long), byte length.
:param seed: murmur hash seed hazelcast uses 0x01000193
:return: (int32... |
Calculates the request payload size | def calculate_size(name, index, value):
""" Calculates the request payload size"""
data_size = 0
data_size += calculate_size_str(name)
data_size += INT_SIZE_IN_BYTES
data_size += calculate_size_data(value)
return data_size |
Calculates the request payload size | def calculate_size(name, index):
""" Calculates the request payload size"""
data_size = 0
data_size += calculate_size_str(name)
data_size += INT_SIZE_IN_BYTES
return data_size |
Adds the specified item to the end of this list.
:param item: (object), the specified item to be appended to this list.
:return: (bool), ``true`` if item is added, ``false`` otherwise. | def add(self, item):
"""
Adds the specified item to the end of this list.
:param item: (object), the specified item to be appended to this list.
:return: (bool), ``true`` if item is added, ``false`` otherwise.
"""
check_not_none(item, "Value can't be None")
eleme... |
Adds the specified item at the specific position in this list. Element in this position and following elements
are shifted to the right, if any.
:param index: (int), the specified index to insert the item.
:param item: (object), the specified item to be inserted. | def add_at(self, index, item):
"""
Adds the specified item at the specific position in this list. Element in this position and following elements
are shifted to the right, if any.
:param index: (int), the specified index to insert the item.
:param item: (object), the specified i... |
Adds all of the items in the specified collection to the end of this list. The order of new elements is
determined by the specified collection's iterator.
:param items: (Collection), the specified collection which includes the elements to be added to list.
:return: (bool), ``true`` if this call... | def add_all(self, items):
"""
Adds all of the items in the specified collection to the end of this list. The order of new elements is
determined by the specified collection's iterator.
:param items: (Collection), the specified collection which includes the elements to be added to list.
... |
Adds all of the elements in the specified collection into this list at the specified position. Elements in this
positions and following elements are shifted to the right, if any. The order of new elements is determined by the
specified collection's iterator.
:param index: (int), the specified i... | def add_all_at(self, index, items):
"""
Adds all of the elements in the specified collection into this list at the specified position. Elements in this
positions and following elements are shifted to the right, if any. The order of new elements is determined by the
specified collection's... |
Determines whether this list contains all of the items in specified collection or not.
:param items: (Collection), the specified collection which includes the items to be searched.
:return: (bool), ``true`` if all of the items in specified collection exist in this list, ``false`` otherwise. | def contains_all(self, items):
"""
Determines whether this list contains all of the items in specified collection or not.
:param items: (Collection), the specified collection which includes the items to be searched.
:return: (bool), ``true`` if all of the items in specified collection e... |
Returns the first index of specified items's occurrences in this list. If specified item is not present in this
list, returns -1.
:param item: (object), the specified item to be searched for.
:return: (int), the first index of specified items's occurrences, -1 if item is not present in this lis... | def index_of(self, item):
"""
Returns the first index of specified items's occurrences in this list. If specified item is not present in this
list, returns -1.
:param item: (object), the specified item to be searched for.
:return: (int), the first index of specified items's occu... |
Returns the last index of specified items's occurrences in this list. If specified item is not present in this
list, returns -1.
:param item: (object), the specified item to be searched for.
:return: (int), the last index of specified items's occurrences, -1 if item is not present in this list. | def last_index_of(self, item):
"""
Returns the last index of specified items's occurrences in this list. If specified item is not present in this
list, returns -1.
:param item: (object), the specified item to be searched for.
:return: (int), the last index of specified items's o... |
Removes the specified element's first occurrence from the list if it exists in this list.
:param item: (object), the specified element.
:return: (bool), ``true`` if the specified element is present in this list. | def remove(self, item):
"""
Removes the specified element's first occurrence from the list if it exists in this list.
:param item: (object), the specified element.
:return: (bool), ``true`` if the specified element is present in this list.
"""
check_not_none(item, "Value... |
Removes all of the elements that is present in the specified collection from this list.
:param items: (Collection), the specified collection.
:return: (bool), ``true`` if this list changed as a result of the call. | def remove_all(self, items):
"""
Removes all of the elements that is present in the specified collection from this list.
:param items: (Collection), the specified collection.
:return: (bool), ``true`` if this list changed as a result of the call.
"""
check_not_none(items... |
Removes the specified item listener. Returns silently if the specified listener was not added before.
:param registration_id: (str), id of the listener to be deleted.
:return: (bool), ``true`` if the item listener is removed, ``false`` otherwise. | def remove_listener(self, registration_id):
"""
Removes the specified item listener. Returns silently if the specified listener was not added before.
:param registration_id: (str), id of the listener to be deleted.
:return: (bool), ``true`` if the item listener is removed, ``false`` oth... |
Retains only the items that are contained in the specified collection. It means, items which are not present in
the specified collection are removed from this list.
:param items: (Collection), collections which includes the elements to be retained in this list.
:return: (bool), ``true`` if this... | def retain_all(self, items):
"""
Retains only the items that are contained in the specified collection. It means, items which are not present in
the specified collection are removed from this list.
:param items: (Collection), collections which includes the elements to be retained in thi... |
Replaces the specified element with the element at the specified position in this list.
:param index: (int), index of the item to be replaced.
:param item: (object), item to be stored.
:return: (object), the previous item in the specified index. | def set_at(self, index, item):
"""
Replaces the specified element with the element at the specified position in this list.
:param index: (int), index of the item to be replaced.
:param item: (object), item to be stored.
:return: (object), the previous item in the specified index... |
Returns a sublist from this list, whose range is specified with from_index(inclusive) and to_index(exclusive).
The returned list is backed by this list, so non-structural changes in the returned list are reflected in this
list, and vice-versa.
:param from_index: (int), the start point(inclusive... | def sub_list(self, from_index, to_index):
"""
Returns a sublist from this list, whose range is specified with from_index(inclusive) and to_index(exclusive).
The returned list is backed by this list, so non-structural changes in the returned list are reflected in this
list, and vice-versa... |
Adds a continuous entry listener for this map. Listener will get notified for map events filtered with given
parameters.
:param include_value: (bool), whether received event should include the value or not (optional).
:param key: (object), key for filtering the events (optional).
:param... | def add_entry_listener(self, include_value=False, key=None, predicate=None, added_func=None, removed_func=None, updated_func=None,
evicted_func=None, evict_all_func=None, clear_all_func=None, merged_func=None, expired_func=None):
"""
Adds a continuous entry listener for this m... |
Adds an index to this map for the specified entries so that queries can run faster.
Example:
Let's say your map values are Employee objects.
>>> class Employee(IdentifiedDataSerializable):
>>> active = false
>>> age = None
>>> ... | def add_index(self, attribute, ordered=False):
"""
Adds an index to this map for the specified entries so that queries can run faster.
Example:
Let's say your map values are Employee objects.
>>> class Employee(IdentifiedDataSerializable):
>>> act... |
Adds an interceptor for this map. Added interceptor will intercept operations and execute user defined methods.
:param interceptor: (object), interceptor for the map which includes user defined methods.
:return: (str),id of registered interceptor. | def add_interceptor(self, interceptor):
"""
Adds an interceptor for this map. Added interceptor will intercept operations and execute user defined methods.
:param interceptor: (object), interceptor for the map which includes user defined methods.
:return: (str),id of registered intercep... |
Determines whether this map contains an entry with the key.
**Warning: This method uses __hash__ and __eq__ methods of binary form of the key, not the actual implementations
of __hash__ and __eq__ defined in key's class.**
:param key: (object), the specified key.
:return: (bool), ``tru... | def contains_key(self, key):
"""
Determines whether this map contains an entry with the key.
**Warning: This method uses __hash__ and __eq__ methods of binary form of the key, not the actual implementations
of __hash__ and __eq__ defined in key's class.**
:param key: (object), ... |
Determines whether this map contains one or more keys for the specified value.
:param value: (object), the specified value.
:return: (bool), ``true`` if this map contains an entry for the specified value. | def contains_value(self, value):
"""
Determines whether this map contains one or more keys for the specified value.
:param value: (object), the specified value.
:return: (bool), ``true`` if this map contains an entry for the specified value.
"""
check_not_none(value, "va... |
Removes the mapping for a key from this map if it is present (optional operation).
Unlike remove(object), this operation does not return the removed value, which avoids the serialization cost of
the returned value. If the removed value will not be used, a delete operation is preferred over a remove
... | def delete(self, key):
"""
Removes the mapping for a key from this map if it is present (optional operation).
Unlike remove(object), this operation does not return the removed value, which avoids the serialization cost of
the returned value. If the removed value will not be used, a dele... |
Returns a list clone of the mappings contained in this map.
**Warning:
The list is NOT backed by the map, so changes to the map are NOT reflected in the list, and vice-versa.**
:param predicate: (Predicate), predicate for the map to filter entries (optional).
:return: (Sequence), the l... | def entry_set(self, predicate=None):
"""
Returns a list clone of the mappings contained in this map.
**Warning:
The list is NOT backed by the map, so changes to the map are NOT reflected in the list, and vice-versa.**
:param predicate: (Predicate), predicate for the map to filt... |
Evicts the specified key from this map.
**Warning: This method uses __hash__ and __eq__ methods of binary form of the key, not the actual implementations
of __hash__ and __eq__ defined in key's class.**
:param key: (object), key to evict.
:return: (bool), ``true`` if the key is evicted... | def evict(self, key):
"""
Evicts the specified key from this map.
**Warning: This method uses __hash__ and __eq__ methods of binary form of the key, not the actual implementations
of __hash__ and __eq__ defined in key's class.**
:param key: (object), key to evict.
:retu... |
Applies the user defined EntryProcessor to all the entries in the map or entries in the map which satisfies
the predicate if provided. Returns the results mapped by each key in the map.
:param entry_processor: (object), A stateful serializable object which represents the EntryProcessor defined on
... | def execute_on_entries(self, entry_processor, predicate=None):
"""
Applies the user defined EntryProcessor to all the entries in the map or entries in the map which satisfies
the predicate if provided. Returns the results mapped by each key in the map.
:param entry_processor: (object), ... |
Applies the user defined EntryProcessor to the entry mapped by the key. Returns the object which is the result
of EntryProcessor's process method.
:param key: (object), specified key for the entry to be processed.
:param entry_processor: (object), A stateful serializable object which represents... | def execute_on_key(self, key, entry_processor):
"""
Applies the user defined EntryProcessor to the entry mapped by the key. Returns the object which is the result
of EntryProcessor's process method.
:param key: (object), specified key for the entry to be processed.
:param entry_... |
Applies the user defined EntryProcessor to the entries mapped by the collection of keys. Returns the results
mapped by each key in the collection.
:param keys: (Collection), collection of the keys for the entries to be processed.
:param entry_processor: (object), A stateful serializable object ... | def execute_on_keys(self, keys, entry_processor):
"""
Applies the user defined EntryProcessor to the entries mapped by the collection of keys. Returns the results
mapped by each key in the collection.
:param keys: (Collection), collection of the keys for the entries to be processed.
... |
Releases the lock for the specified key regardless of the lock owner. It always successfully unlocks the key,
never blocks, and returns immediately.
**Warning: This method uses __hash__ and __eq__ methods of binary form of the key, not the actual implementations
of __hash__ and __eq__ defined i... | def force_unlock(self, key):
"""
Releases the lock for the specified key regardless of the lock owner. It always successfully unlocks the key,
never blocks, and returns immediately.
**Warning: This method uses __hash__ and __eq__ methods of binary form of the key, not the actual impleme... |
Returns the value for the specified key, or ``None`` if this map does not contain this key.
**Warning:
This method returns a clone of original value, modifying the returned value does not change the actual value in
the map. One should put modified value back to make changes visible to all nodes... | def get(self, key):
"""
Returns the value for the specified key, or ``None`` if this map does not contain this key.
**Warning:
This method returns a clone of original value, modifying the returned value does not change the actual value in
the map. One should put modified value b... |
Returns the entries for the given keys.
**Warning:
The returned map is NOT backed by the original map, so changes to the original map are NOT reflected in the
returned map, and vice-versa.**
**Warning 2: This method uses __hash__ and __eq__ methods of binary form of the key, not the ac... | def get_all(self, keys):
"""
Returns the entries for the given keys.
**Warning:
The returned map is NOT backed by the original map, so changes to the original map are NOT reflected in the
returned map, and vice-versa.**
**Warning 2: This method uses __hash__ and __eq__ ... |
Returns the EntryView for the specified key.
**Warning:
This method returns a clone of original mapping, modifying the returned value does not change the actual value
in the map. One should put modified value back to make changes visible to all nodes.**
**Warning 2: This method uses __... | def get_entry_view(self, key):
"""
Returns the EntryView for the specified key.
**Warning:
This method returns a clone of original mapping, modifying the returned value does not change the actual value
in the map. One should put modified value back to make changes visible to all... |
Checks the lock for the specified key. If the lock is acquired, it returns ``true``. Otherwise, it returns ``false``.
**Warning: This method uses __hash__ and __eq__ methods of binary form of the key, not the actual implementations
of __hash__ and __eq__ defined in key's class.**
:param key: (... | def is_locked(self, key):
"""
Checks the lock for the specified key. If the lock is acquired, it returns ``true``. Otherwise, it returns ``false``.
**Warning: This method uses __hash__ and __eq__ methods of binary form of the key, not the actual implementations
of __hash__ and __eq__ de... |
Returns a List clone of the keys contained in this map or the keys of the entries filtered with the predicate if
provided.
**Warning:
The list is NOT backed by the map, so changes to the map are NOT reflected in the list, and vice-versa.**
:param predicate: (Predicate), predicate to fi... | def key_set(self, predicate=None):
"""
Returns a List clone of the keys contained in this map or the keys of the entries filtered with the predicate if
provided.
**Warning:
The list is NOT backed by the map, so changes to the map are NOT reflected in the list, and vice-versa.**
... |
Loads all keys from the store at server side or loads the given keys if provided.
:param keys: (Collection), keys of the entry values to load (optional).
:param replace_existing_values: (bool), whether the existing values will be replaced or not with those loaded
from the server side MapLoader ... | def load_all(self, keys=None, replace_existing_values=True):
"""
Loads all keys from the store at server side or loads the given keys if provided.
:param keys: (Collection), keys of the entry values to load (optional).
:param replace_existing_values: (bool), whether the existing values ... |
Acquires the lock for the specified key infinitely or for the specified lease time if provided.
If the lock is not available, the current thread becomes disabled for thread scheduling purposes and lies
dormant until the lock has been acquired.
You get a lock whether the value is present in the... | def lock(self, key, ttl=-1):
"""
Acquires the lock for the specified key infinitely or for the specified lease time if provided.
If the lock is not available, the current thread becomes disabled for thread scheduling purposes and lies
dormant until the lock has been acquired.
Y... |
Associates the specified value with the specified key in this map. If the map previously contained a mapping for
the key, the old value is replaced by the specified value. If ttl is provided, entry will expire and get evicted
after the ttl.
**Warning:
This method returns a clone of the ... | def put(self, key, value, ttl=-1):
"""
Associates the specified value with the specified key in this map. If the map previously contained a mapping for
the key, the old value is replaced by the specified value. If ttl is provided, entry will expire and get evicted
after the ttl.
... |
Copies all of the mappings from the specified map to this map. No atomicity guarantees are
given. In the case of a failure, some of the key-value tuples may get written, while others are not.
:param map: (dict), map which includes mappings to be stored in this map. | def put_all(self, map):
"""
Copies all of the mappings from the specified map to this map. No atomicity guarantees are
given. In the case of a failure, some of the key-value tuples may get written, while others are not.
:param map: (dict), map which includes mappings to be stored in thi... |
Associates the specified key with the given value if it is not already associated. If ttl is provided, entry
will expire and get evicted after the ttl.
This is equivalent to:
>>> if not map.contains_key(key):
>>> return map.put(key,value)
>>> else:
>>... | def put_if_absent(self, key, value, ttl=-1):
"""
Associates the specified key with the given value if it is not already associated. If ttl is provided, entry
will expire and get evicted after the ttl.
This is equivalent to:
>>> if not map.contains_key(key):
>>> ... |
Same as put(TKey, TValue, Ttl), but MapStore defined at the server side will not be called.
**Warning: This method uses __hash__ and __eq__ methods of binary form of the key, not the actual implementations
of __hash__ and __eq__ defined in key's class.**
:param key: (object), key of the entry.... | def put_transient(self, key, value, ttl=-1):
"""
Same as put(TKey, TValue, Ttl), but MapStore defined at the server side will not be called.
**Warning: This method uses __hash__ and __eq__ methods of binary form of the key, not the actual implementations
of __hash__ and __eq__ defined i... |
Removes the mapping for a key from this map if it is present. The map will not contain a mapping for the
specified key once the call returns.
**Warning: This method uses __hash__ and __eq__ methods of binary form of the key, not the actual implementations
of __hash__ and __eq__ defined in key's... | def remove(self, key):
"""
Removes the mapping for a key from this map if it is present. The map will not contain a mapping for the
specified key once the call returns.
**Warning: This method uses __hash__ and __eq__ methods of binary form of the key, not the actual implementations
... |
Removes the entry for a key only if it is currently mapped to a given value.
This is equivalent to:
>>> if map.contains_key(key) and map.get(key).equals(value):
>>> map.remove(key)
>>> return true
>>> else:
>>> return false
except ... | def remove_if_same(self, key, value):
"""
Removes the entry for a key only if it is currently mapped to a given value.
This is equivalent to:
>>> if map.contains_key(key) and map.get(key).equals(value):
>>> map.remove(key)
>>> return true
... |
Removes the specified entry listener. Returns silently if there is no such listener added before.
:param registration_id: (str), id of registered listener.
:return: (bool), ``true`` if registration is removed, ``false`` otherwise. | def remove_entry_listener(self, registration_id):
"""
Removes the specified entry listener. Returns silently if there is no such listener added before.
:param registration_id: (str), id of registered listener.
:return: (bool), ``true`` if registration is removed, ``false`` otherwise.
... |
Replaces the entry for a key only if it is currently mapped to some value.
This is equivalent to:
>>> if map.contains_key(key):
>>> return map.put(key,value)
>>> else:
>>> return None
except that the action is performed atomically.
**Warn... | def replace(self, key, value):
"""
Replaces the entry for a key only if it is currently mapped to some value.
This is equivalent to:
>>> if map.contains_key(key):
>>> return map.put(key,value)
>>> else:
>>> return None
except that ... |
Replaces the entry for a key only if it is currently mapped to a given value.
This is equivalent to:
>>> if map.contains_key(key) and map.get(key).equals(old_value):
>>> map.put(key, new_value)
>>> return true
>>> else:
>>> return false
... | def replace_if_same(self, key, old_value, new_value):
"""
Replaces the entry for a key only if it is currently mapped to a given value.
This is equivalent to:
>>> if map.contains_key(key) and map.get(key).equals(old_value):
>>> map.put(key, new_value)
>>>... |
Puts an entry into this map. Similar to the put operation except that set doesn't return the old value, which is
more efficient. If ttl is provided, entry will expire and get evicted after the ttl.
**Warning: This method uses __hash__ and __eq__ methods of binary form of the key, not the actual impleme... | def set(self, key, value, ttl=-1):
"""
Puts an entry into this map. Similar to the put operation except that set doesn't return the old value, which is
more efficient. If ttl is provided, entry will expire and get evicted after the ttl.
**Warning: This method uses __hash__ and __eq__ me... |
Tries to acquire the lock for the specified key. When the lock is not available,
* If timeout is not provided, the current thread doesn't wait and returns ``false`` immediately.
* If a timeout is provided, the current thread becomes disabled for thread scheduling purposes and lies
... | def try_lock(self, key, ttl=-1, timeout=0):
"""
Tries to acquire the lock for the specified key. When the lock is not available,
* If timeout is not provided, the current thread doesn't wait and returns ``false`` immediately.
* If a timeout is provided, the current thread become... |
Tries to put the given key and value into this map and returns immediately if timeout is not provided. If
timeout is provided, operation waits until it is completed or timeout is reached.
:param key: (object), key of the entry.
:param value: (object), value of the entry.
:param timeout:... | def try_put(self, key, value, timeout=0):
"""
Tries to put the given key and value into this map and returns immediately if timeout is not provided. If
timeout is provided, operation waits until it is completed or timeout is reached.
:param key: (object), key of the entry.
:para... |
Tries to remove the given key from this map and returns immediately if timeout is not provided. If
timeout is provided, operation waits until it is completed or timeout is reached.
:param key: (object), key of the entry to be deleted.
:param timeout: (int), operation timeout in seconds (optiona... | def try_remove(self, key, timeout=0):
"""
Tries to remove the given key from this map and returns immediately if timeout is not provided. If
timeout is provided, operation waits until it is completed or timeout is reached.
:param key: (object), key of the entry to be deleted.
:p... |
Releases the lock for the specified key. It never blocks and returns immediately. If the current thread is the
holder of this lock, then the hold count is decremented. If the hold count is zero, then the lock is released.
:param key: (object), the key to lock. | def unlock(self, key):
"""
Releases the lock for the specified key. It never blocks and returns immediately. If the current thread is the
holder of this lock, then the hold count is decremented. If the hold count is zero, then the lock is released.
:param key: (object), the key to lock.... |
Returns a list clone of the values contained in this map or values of the entries which are filtered with
the predicate if provided.
**Warning:
The list is NOT backed by the map, so changes to the map are NOT reflected in the list, and
vice-versa.**
:param predicate: (Predicate... | def values(self, predicate=None):
"""
Returns a list clone of the values contained in this map or values of the entries which are filtered with
the predicate if provided.
**Warning:
The list is NOT backed by the map, so changes to the map are NOT reflected in the list, and
... |
Creates a Transaction object with given timeout, durability and transaction type.
:param timeout: (long), the timeout in seconds determines the maximum lifespan of a transaction.
:param durability: (int), the durability is the number of machines that can take over if a member fails during a
... | def new_transaction(self, timeout, durability, transaction_type):
"""
Creates a Transaction object with given timeout, durability and transaction type.
:param timeout: (long), the timeout in seconds determines the maximum lifespan of a transaction.
:param durability: (int), the durabili... |
Begins this transaction. | def begin(self):
"""
Begins this transaction.
"""
if hasattr(self._locals, 'transaction_exists') and self._locals.transaction_exists:
raise TransactionError("Nested transactions are not allowed.")
if self.state != _STATE_NOT_STARTED:
raise TransactionError... |
Commits this transaction. | def commit(self):
"""
Commits this transaction.
"""
self._check_thread()
if self.state != _STATE_ACTIVE:
raise TransactionError("Transaction is not active.")
try:
self._check_timeout()
request = transaction_commit_codec.encode_request(s... |
Rollback of this current transaction. | def rollback(self):
"""
Rollback of this current transaction.
"""
self._check_thread()
if self.state not in (_STATE_ACTIVE, _STATE_PARTIAL_COMMIT):
raise TransactionError("Transaction is not active.")
try:
if self.state != _STATE_PARTIAL_COMMIT:
... |
Calculates the request payload size | def calculate_size(transaction_id, thread_id):
""" Calculates the request payload size"""
data_size = 0
data_size += calculate_size_str(transaction_id)
data_size += LONG_SIZE_IN_BYTES
return data_size |
Loads member addresses from Hazelcast.cloud endpoint.
:return: (Sequence), The possible member addresses to connect to. | def load_addresses(self):
"""
Loads member addresses from Hazelcast.cloud endpoint.
:return: (Sequence), The possible member addresses to connect to.
"""
try:
return list(self.cloud_discovery.discover_nodes().keys())
except Exception as ex:
self.l... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.