Removes a topic message listener.

@param consumerGroupId
@param topic
@param messageListener
@return {@code true} if successful, {@code false} otherwise (the topic
may have no such listener added before)
968123
public boolean removeMessageListener(String consumerGroupId, String topic,
            IKafkaMessageListener messageListener) {
        KafkaMsgConsumer kafkaConsumer = cacheConsumers.get(consumerGroupId);
        return kafkaConsumer != null ? kafkaConsumer.removeMessageListener(topic, messageListener)
                : false;
    }
1278218
@Override
	public void removeByGroupId(long groupId) {
		for (CommerceUserSegmentEntry commerceUserSegmentEntry : findByGroupId(
				groupId, QueryUtil.ALL_POS, QueryUtil.ALL_POS, null)) {
			remove(commerceUserSegmentEntry);
		}
	}
854450
public boolean removeMessageFilter(MessageFilter messageFilter, boolean bFreeFilter)
    {
        boolean bSuccess = false;
        try   {
            if (((BaseMessageFilter)messageFilter).getRemoteFilterID() == null)
                bSuccess = true;    // No remote filter to remove
            else
                bSuccess = m_receiveQueue.removeRemoteMessageFilter((BaseMessageFilter)messageFilter, bFreeFilter);
        } catch (RemoteException ex)    {
            ex.printStackTrace();
        }
        if (!bSuccess)
            Util.getLogger().warning("Remote listener not removed"); // Never
        return super.removeMessageFilter(messageFilter, bFreeFilter);
    }
228284
void removeRegistrations(String topic) {
        Collection<Registration> all = registrations.remove(topic);
        if (all == null) {
            return;
        }
        for (Registration reg : all) {
            registrationIdMap.remove(reg.getId());
            pingNotifiableEventListener(topic, reg, false);
        }
    }
1118253
public void freeFiltersWithListener(JMessageListener listener)
    {
        if (m_messageMap != null)
        {
            for (BaseMessageQueue messageQueue : m_messageMap.values())
            {
                if (messageQueue != null)
                    messageQueue.freeFiltersWithListener(listener);
            }
        }
    }
54327
public synchronized boolean removeIncomingChatMarkerMessageListener(ChatMarkersListener listener) {
        boolean res = incomingListeners.remove(listener);
        if (incomingListeners.isEmpty() && enabled) {
            serviceDiscoveryManager.removeFeature(ChatMarkersElements.NAMESPACE);
            enabled = false;
        }
        return res;
    }
1229379
@Override
	public void removeListeners(String nodeID) {
		boolean found = false;
		writeLock.lock();
		try {
			Iterator<HashMap<String, Strategy<ListenerEndpoint>>> groupIterator = listeners.values().iterator();
			while (groupIterator.hasNext()) {
				HashMap<String, Strategy<ListenerEndpoint>> groups = groupIterator.next();
				Iterator<Strategy<ListenerEndpoint>> strategyIterator = groups.values().iterator();
				while (strategyIterator.hasNext()) {
					Strategy<ListenerEndpoint> strategy = strategyIterator.next();
					if (strategy.remove(nodeID)) {
						found = true;
						if (strategy.isEmpty()) {
							strategyIterator.remove();
						}
					}
				}
				if (groups.isEmpty()) {
					groupIterator.remove();
				}
			}
		} finally {

			// Clear caches
			if (found) {
				emitterCache.clear();
				broadcasterCache.clear();
				localBroadcasterCache.clear();
			}

			writeLock.unlock();
		}
	}
1232428
public boolean commit(String topic) {
        KafkaConsumer<String, byte[]> consumer = _getConsumer(topic);
        synchronized (consumer) {
            Set<String> subscription = consumer.subscription();
            if (subscription == null || !subscription.contains(topic)) {
                // this consumer has not subscribed to the topic
                return false;
            }
            try {
                consumer.commitSync();
            } catch (WakeupException e) {
            } catch (Exception e) {
                throw new KafkaException(e);
            }
            return true;
        }
    }
208926
void processUnsubscribe(ServerChannel session, String clientID, List<String> topics, int messageID) {
        Log.trace("processUnsubscribe invoked, removing subscription on topics {}, for clientID <{}>", topics, clientID);

        for (String topic : topics) {
            subscriptions.removeSubscription(topic, clientID);
        }
        //ack the client
        UnsubAckMessage ackMessage = new UnsubAckMessage();
        ackMessage.setMessageID(messageID);

        Log.trace("replying with UnsubAck to MSG ID {}", messageID);
        session.write(ackMessage);
    }
163113
@Override
	public void removeByGroupId(long groupId) {
		for (CommerceDiscountUsageEntry commerceDiscountUsageEntry : findByGroupId(
				groupId, QueryUtil.ALL_POS, QueryUtil.ALL_POS, null)) {
			remove(commerceDiscountUsageEntry);
		}
	}
1263275
@SuppressWarnings("unlikely-arg-type")
    public boolean unsubscribe(IConsumer consumer) {
        if (consumers.remove(consumer)) {
            fireConsumerConnectionEvent(consumer, PipeConnectionEvent.EventType.CONSUMER_DISCONNECT, null);
            listeners.remove(consumer);
            return true;
        }
        return false;
    }
901997
private void removeListener(CmsUUID listenerId) {

        getRequest().getSession().removeAttribute(SESSION_ATTRIBUTE_LISTENER_ID);
        m_listeners.remove(listenerId);
    }
61520
public boolean addMessageListener(String topic, IKafkaMessageListener messageListener,
            boolean autoCommitOffsets) {
        synchronized (topicMsgListeners) {
            if (topicMsgListeners.put(topic, messageListener)) {
                _getWorker(topic, autoCommitOffsets);
                return true;
            }
        }
        return false;
    }
1171031
public boolean removeNotificationListener(String mbeanName, NotificationListener listener) throws Exception {
        if (isConnected()) {
            ObjectName objectName = new ObjectName(mbeanName);
            mbsc.removeNotificationListener(objectName, listener, null, null);
            jmxc.removeConnectionNotificationListener(listener);
            return true;
        } else {
            return false;
        }
    }
413658
@Override
	public void removeByG_E(long groupId, boolean enabled) {
		for (CommerceNotificationTemplate commerceNotificationTemplate : findByG_E(
				groupId, enabled, QueryUtil.ALL_POS, QueryUtil.ALL_POS, null)) {
			remove(commerceNotificationTemplate);
		}
	}
287874
@SuppressWarnings("unused")
    public void destroy() {
        // stop all workers
        for (KafkaMsgConsumerWorker worker : topicWorkers.values()) {
            try {
                worker.stopWorker();
            } catch (Exception e) {
                LOGGER.warn(e.getMessage(), e);
            }
        }
        topicWorkers.clear();

        // clear all message listeners
        synchronized (topicMsgListeners) {
            topicMsgListeners.clear();
        }

        // close all KafkaConsumer
        for (KafkaConsumer<String, byte[]> consumer : topicConsumers.values()) {
            synchronized (consumer) {
                try {
                    consumer.close();
                } catch (WakeupException e) {
                } catch (Exception e) {
                    LOGGER.warn(e.getMessage(), e);
                }
            }
        }
        topicConsumers.clear();

        if (executorService != null && myOwnExecutorService) {
            try {
                List<Runnable> tasks = executorService.shutdownNow();
            } catch (Exception e) {
                LOGGER.warn(e.getMessage(), e);
            } finally {
                executorService = null;
            }
        }
    }
1071110
public Closeable onUnsubscribeChannelEvent(final Consumer<BitfinexStreamSymbol> listener) {
        unsubscribeChannelConsumers.offer(listener);
        return () -> unsubscribeChannelConsumers.remove(listener);
    }