Example #1
0
    def add_entry_listener(self, include_value=False, added=None, clear_all=None, evicted=None,
                           evict_all=None, expired=None, merged=None, removed=None,
                           updated=None):
        flags = self._get_listener_flags(added=added,
                                         clear_all=clear_all,
                                         evicted=evicted,
                                         evict_all=evict_all,
                                         expired=expired,
                                         merged=merged,
                                         removed=removed,
                                         updated=updated)
        request = map_add_entry_listener_codec.encode_request(self.name, include_value, flags, False)

        handler_list = locals()

        def handle_event_entry(key, value, old_value, merging_value, event_type, uuid, number_of_affected_entries):
            # TODO: this should be called directly with kwargs
            event = EntryEvent(key=self._to_object(key), value=self._to_object(value),
                               old_value=self._to_object(old_value), merging_value=self._to_object(merging_value),
                               event_type=event_type, uuid=uuid, number_of_affected_entries=number_of_affected_entries)

            event_name = EntryEventType.reverse[event_type]
            handler_list[event_name](event)

        response = self._start_listening(request, lambda m: map_add_entry_listener_codec.handle(m, handle_event_entry))
        return map_add_entry_listener_codec.decode_response(response)['response']
    def add_entry_listener(self, include_value=False, key=None, predicate=None, added=None, removed=None, updated=None,
                           evicted=None, evict_all=None, clear_all=None, merged=None, expired=None):
        flags = get_entry_listener_flags(added=added, removed=removed, updated=updated,
                                         evicted=evicted, evict_all=evict_all, clear_all=clear_all, merged=merged,
                                         expired=expired)

        if key and predicate:
            key_data = self._to_data(key)
            predicate_data = self._to_data(predicate)
            request = map_add_entry_listener_to_key_with_predicate_codec.encode_request(self.name, key_data,
                                                                                        predicate_data, include_value,
                                                                                        flags, False)
        elif key and not predicate:
            key_data = self._to_data(key)
            request = map_add_entry_listener_to_key_codec.encode_request(self.name, key_data, include_value, flags,
                                                                         False)
        elif not key and predicate:
            predicate = self._to_data(predicate)
            request = map_add_entry_listener_with_predicate_codec.encode_request(self.name, predicate, include_value,
                                                                                 flags, False)
        else:
            request = map_add_entry_listener_codec.encode_request(self.name, include_value, flags, False)

        def handle_event_entry(**_kwargs):
            event = EntryEvent(self._to_object, **_kwargs)
            if event.event_type == EntryEventType.added:
                added(event)
            elif event.event_type == EntryEventType.removed:
                removed(event)
            elif event.event_type == EntryEventType.updated:
                updated(event)
            elif event.event_type == EntryEventType.evicted:
                evicted(event)
            elif event.event_type == EntryEventType.evict_all:
                evict_all(event)
            elif event.event_type == EntryEventType.clear_all:
                clear_all(event)
            elif event.event_type == EntryEventType.merged:
                merged(event)
            elif event.event_type == EntryEventType.expired:
                expired(event)

        return self._start_listening(request,
                                     lambda m: map_add_entry_listener_codec.handle(m,
                                                                                   handle_event_entry),
                                     lambda r: map_add_entry_listener_codec.decode_response(r)[
                                         'response'])
Example #3
0
File: map.py Project: OlyaT/FunFic
    def add_entry_listener(self,
                           include_value=False,
                           key=None,
                           predicate=None,
                           added=None,
                           removed=None,
                           updated=None,
                           evicted=None,
                           evict_all=None,
                           clear_all=None,
                           merged=None,
                           expired=None):
        flags = get_entry_listener_flags(added=added,
                                         removed=removed,
                                         updated=updated,
                                         evicted=evicted,
                                         evict_all=evict_all,
                                         clear_all=clear_all,
                                         merged=merged,
                                         expired=expired)

        if key and predicate:
            key_data = self._to_data(key)
            predicate_data = self._to_data(predicate)
            request = map_add_entry_listener_to_key_with_predicate_codec.encode_request(
                self.name, key_data, predicate_data, include_value, flags,
                False)
        elif key and not predicate:
            key_data = self._to_data(key)
            request = map_add_entry_listener_to_key_codec.encode_request(
                self.name, key_data, include_value, flags, False)
        elif not key and predicate:
            predicate = self._to_data(predicate)
            request = map_add_entry_listener_with_predicate_codec.encode_request(
                self.name, predicate, include_value, flags, False)
        else:
            request = map_add_entry_listener_codec.encode_request(
                self.name, include_value, flags, False)

        def handle_event_entry(**_kwargs):
            event = EntryEvent(self._to_object, **_kwargs)
            if event.event_type == EntryEventType.added:
                added(event)
            elif event.event_type == EntryEventType.removed:
                removed(event)
            elif event.event_type == EntryEventType.updated:
                updated(event)
            elif event.event_type == EntryEventType.evicted:
                evicted(event)
            elif event.event_type == EntryEventType.evict_all:
                evict_all(event)
            elif event.event_type == EntryEventType.clear_all:
                clear_all(event)
            elif event.event_type == EntryEventType.merged:
                merged(event)
            elif event.event_type == EntryEventType.expired:
                expired(event)

        return self._start_listening(
            request, lambda m: map_add_entry_listener_codec.handle(
                m, handle_event_entry), lambda r: map_add_entry_listener_codec.
            decode_response(r)['response'])