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
        parameters.

        :param key: (object), key for filtering the events (optional).
        :param predicate: (Predicate), predicate for filtering the events (optional).
        :param added_func: Function to be called when an entry is added to map (optional).
        :param removed_func: Function to be called when an entry is removed from map (optional).
        :param updated_func: Function to be called when an entry is updated (optional).
        :param evicted_func: Function to be called when an entry is evicted from map (optional).
        :param clear_all_func: Function to be called when entries are cleared from map (optional).
        :return: (str), a registration id which is used as a key to remove the listener.

        .. seealso:: :class:`~hazelcast.serialization.predicate.Predicate` for more info about predicates.
        """
        if key and predicate:
            key_data = self._to_data(key)
            predicate_data = self._to_data(predicate)
            request = replicated_map_add_entry_listener_to_key_with_predicate_codec.encode_request(self.name, key_data,
                                                                                                   predicate_data,
                                                                                                   False)
        elif key and not predicate:
            key_data = self._to_data(key)
            request = replicated_map_add_entry_listener_to_key_codec.encode_request(self.name, key_data, False)
        elif not key and predicate:
            predicate = self._to_data(predicate)
            request = replicated_map_add_entry_listener_with_predicate_codec.encode_request(self.name, predicate,
                                                                                            False)
        else:
            request = replicated_map_add_entry_listener_codec.encode_request(self.name, False)

        def handle_event_entry(**_kwargs):
            event = EntryEvent(self._to_object, **_kwargs)
            if event.event_type == EntryEventType.added and added_func:
                added_func(event)
            elif event.event_type == EntryEventType.removed and removed_func:
                removed_func(event)
            elif event.event_type == EntryEventType.updated and updated_func:
                updated_func(event)
            elif event.event_type == EntryEventType.evicted and evicted_func:
                evicted_func(event)
            elif event.event_type == EntryEventType.clear_all and clear_all_func:
                clear_all_func(event)

        return self._start_listening(request,
                                     lambda m: replicated_map_add_entry_listener_codec.handle(m,
                                                                                              handle_event_entry),
                                     lambda r: replicated_map_add_entry_listener_codec.decode_response(r)[
                                         'response'])
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: Function to be called when an entry is added to map (optional).
        :param removed_func: Function to be called when an entry is removed from map (optional).
        :param updated_func: Function to be called when an entry is updated (optional).
        :param evicted_func: Function to be called when an entry is evicted from map (optional).
        :param clear_all_func: Function to be called when entries are cleared from map (optional).
        :return: (str), a registration id which is used as a key to remove the listener.

        .. seealso:: :class:`~hazelcast.serialization.predicate.Predicate` for more info about predicates.