Deactivates all consumers in the given list.

@param consumerHolders The list of consumers to deactivate.
191990
protected void deactivateConsumers(List<ConsumerHolder> consumerHolders) {
        synchronized (activationMonitor) {
            for (ConsumerHolder consumerHolder : consumerHolders) {
                consumerHolder.deactivate();
            }
        }
    }
368986
protected List<ConsumerHolder> filterConsumersForActiveFlag(boolean active) {
        List<ConsumerHolder> consumerHolderSubList = new LinkedList<ConsumerHolder>();
        for (ConsumerHolder consumerHolder : consumerHolders) {
            if (consumerHolder.isActive() == active) {
                consumerHolderSubList.add(consumerHolder);
            }
        }
        return consumerHolderSubList;
    }
590439
private void deactivateEndpoints(Set<MessageEndpointFactoryImpl> mefs) {
        for (MessageEndpointFactoryImpl mef : mefs) {
            if (mef.runtimeActivated) {
                deactivateEndpointInternal(mef);
            }
        }
    }
935428
void removeConsumerSession(ConsumerSessionImpl consumer)
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(tc, "removeConsumerSession", consumer);

        synchronized (_consumers)
        {
            _consumers.remove(consumer);
        }

        _messageProcessor.removeConsumer(consumer);

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(tc, "removeConsumerSession");
    }
1087777
void removeConsumer(JmsMsgConsumerImpl consumer) throws JMSException {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(this, tc, "removeConsumer", consumer);

        // if DUPS_OK_ACKNOWLEDGE is in use, commit any messages delivered in the
        // last incomplete batch (if the session is closing it will already have
        // done this and the count of uncommitted messages will be zero)
        if ((acknowledgeMode == Session.DUPS_OK_ACKNOWLEDGE) && (uncommittedReceiveCount > 0)) {
            commitTransaction();
        }
        syncConsumers.remove(consumer);
        asyncConsumers.remove(consumer);

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(this, tc, "removeConsumer");
    }
551678
public KafkaEndpointBuilder consumerProperties(Map<String, Object> consumerProperties) {
        endpoint.getEndpointConfiguration().setConsumerProperties(consumerProperties);
        return this;
    }
121105
protected List<ConsumerHolder> filterConsumersForEnabledFlag(boolean enabled) {
        List<ConsumerHolder> consumerHolderSubList = new LinkedList<ConsumerHolder>();
        for (ConsumerHolder consumerHolder : consumerHolders) {
            if (consumerHolder.isEnabled() == enabled) {
                consumerHolderSubList.add(consumerHolder);
            }
        }
        return consumerHolderSubList;
    }
362027
private void dispose(Collection<Transformer> elements) {
        if (elements != null) {
            for (Transformer<?, ?> element : elements) {
                if (element instanceof Disposable) {
                    ((Disposable) element).dispose();
                }
            }
            elements.clear();
        }
    }
1011788
public void stopConsumer() {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(this, tc, "stopConsumer");
        try {
            // lock the consumerSession to ensure visibility of update to started.
            synchronized (consumerSession) {
                consumerSession.getConsumerSession().stop();
                consumerSession.started = false;
            }
        } catch (Throwable t) {
            FFDCFilter.processException(t,
                                        CLASS_NAME + ".consumeMessages",
                                        CommsConstants.CATASYNCHRHREADER_CONSUME_MSGS_02,
                                        this);
            if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                SibTr.debug(this, tc, "Unable to stop consumer session due to Throwable: " + t);
        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(this, tc, "stopConsumer");
    }
853328
public void closeConsumers() {
        final List<RowProcessingConsumer> configurableConsumers = getConfigurableConsumers();
        final TaskRunner taskRunner = _publishers.getTaskRunner();
        for (RowProcessingConsumer consumer : configurableConsumers) {
            TaskRunnable task = createCloseTask(consumer, null);
            taskRunner.run(task);
        }
    }
596922
public void removeConsumerFromRegisteredMonitors(
    MonitoredConsumer mc,
    ArrayList exactMonitorList,
    ArrayList wildcardMonitorList)
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
        SibTr.entry(
          tc,
          "removeConsumerFromRegisteredMonitors",
          new Object[] { mc,
                         exactMonitorList,
                         wildcardMonitorList });
    // Remove consumer from correct places in the maps
    removeConsumerFromRegisteredMonitorMap(mc, exactMonitorList, _registeredExactConsumerMonitors);

    // Now process the wildcard monitor list
    removeConsumerFromRegisteredMonitorMap(mc, wildcardMonitorList, _registeredWildcardConsumerMonitors);

    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "removeConsumerFromRegisteredMonitors");

  }
32894
protected void enableConsumers(List<ConsumerHolder> consumerHolders) throws IOException {
        checkPreconditions(consumerHolders);
        try {
            for (ConsumerHolder consumerHolder : consumerHolders) {
                consumerHolder.enable();
            }
        } catch (IOException e) {
            LOGGER.error("Failed to enable consumers - disabling already enabled consumers");
            disableConsumers(consumerHolders);
            throw e;
        }
    }
24439
public function deleteConsumer ( $consumer_key, $user_id, $user_is_admin = false )
    {
        if ($user_is_admin)
        {
            $this->query('
                    DELETE FROM oauth_server_registry
                    WHERE osr_consumer_key = \'%s\'
                      AND (osr_usa_id_ref = \'%d\' OR osr_usa_id_ref IS NULL)
                    ', $consumer_key, $user_id);
        }
        else
        {
            $this->query('
                    DELETE FROM oauth_server_registry
                    WHERE osr_consumer_key = \'%s\'
                      AND osr_usa_id_ref   = \'%d\'
                    ', $consumer_key, $user_id);
        }
    }
877025
protected void deactivate(ComponentContext context) {
        deactivated = true;
        if (mbean != null)
            mbean.unregister();
        if (taskStore != null)
            DatabaseTaskStore.unget(persistentStore);
        appTrackerRef.deactivate(context);
        contextSvcRef.deactivate(context);
        controllerRef.deactivate(context);
        localTranCurrentRef.deactivate(context);
        serializationSvcRef.deactivate(context);
        tranMgrRef.deactivate(context);

    }
95303
public void forEach(final IntObjConsumer<String> consumer)
    {
        int counterId = 0;

        final AtomicBuffer metaDataBuffer = this.metaDataBuffer;
        for (int i = 0, capacity = metaDataBuffer.capacity(); i < capacity; i += METADATA_LENGTH)
        {
            final int recordStatus = metaDataBuffer.getIntVolatile(i);

            if (RECORD_ALLOCATED == recordStatus)
            {
                consumer.accept(counterId, labelValue(metaDataBuffer, i));
            }
            else if (RECORD_UNUSED == recordStatus)
            {
                break;
            }

            counterId++;
        }
    }
503224
public void closeConsumers() throws SIResourceException
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(tc, "closeConsumers");

    //Tell any destinations that target this destination to close their consumers
    if (aliasesThatTargetThisDest != null)
    {
      synchronized(aliasesThatTargetThisDest)
      {
        Iterator i = aliasesThatTargetThisDest.iterator();
        while (i.hasNext())
        {
          AbstractAliasDestinationHandler abstractAliasDestinationHandler = 
            (AbstractAliasDestinationHandler) i.next();
          abstractAliasDestinationHandler.closeConsumers();
        }
      }
    }
    
    // Close all consumers
    if (isPubSub())
    {
      SubscriptionTypeFilter filter = new SubscriptionTypeFilter();  
      filter.LOCAL = Boolean.TRUE;  
      SIMPIterator itr = getSubscriptionIndex().iterator(filter);  
      while(itr.hasNext())  
      {  
        ControllableSubscription subscription = (ControllableSubscription)itr.next(); 
        ConsumerDispatcher cd = (ConsumerDispatcher)subscription.getOutputHandler();

        //Look for subscriptions made through this destination (as opposed to
        //through an alias)
        if (cd.getConsumerDispatcherState().getTopicSpaceUuid().equals(getUuid()))
        {
          //Close the consumers of the subscription  
          cd.closeAllConsumersForDelete(this);
        }
      }

      // Remove the ProxyHandlers attached to this destination
      // sanjay liberty change
      //messageProcessor.getProxyHandler().topicSpaceDeletedEvent(this);
      
      //Delete any durable subscriptions if they are made through an alias
      //in-case the underlying topicspace is not being deleted
      if (isAlias())
      {
        itr = getSubscriptionIndex().iterator(filter);  
        while(itr.hasNext())  
        {  
          ControllableSubscription subscription = (ControllableSubscription)itr.next(); 
          ConsumerDispatcher cd = (ConsumerDispatcher)subscription.getOutputHandler();
          ConsumerDispatcherState subState = cd.getConsumerDispatcherState();

          //Look for subscriptions made through this alias
          if ((subState.getTopicSpaceUuid().equals(getUuid())) &&
              (cd.isDurable()))
          {
            try {
              deleteDurableSubscription(subState.getSubscriberID(), subState.getDurableHome());
            } catch (SIException e) 
            {
              FFDCFilter.processException(
                  e,
                  "com.ibm.ws.sib.processor.impl.AbstractDestinationHandler.closeConsumers",
                  "1:347:1.57",
                  this);

              SibTr.exception(tc, e);
            }
          }
        } 
        itr.finished();
        
      }

    }
    else
    {
      LocalizationPoint ptoPMessageItemStream = getQueuePoint(messageProcessor.getMessagingEngineUuid());
      if (ptoPMessageItemStream != null)
      {
        ConsumerDispatcher consumerManager =
          (ConsumerDispatcher)ptoPMessageItemStream.getConsumerManager();
        consumerManager.closeAllConsumersForDelete(this);
      }
    }
    

    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "closeConsumers");

    return;
  }
250126
public void deregisterConsumerSetMonitor(ConnectionImpl connection,
                                           ConsumerSetChangeCallback callback)
  throws SINotPossibleInCurrentConfigurationException
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(tc, "deregisterConsumerSetMonitor", new Object[] { connection, callback });

    // Deregister under a lock on the targets table
    synchronized(_targets)
    {
      _consumerMonitoring.deregisterConsumerSetMonitor(connection, callback);
    }

    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "deregisterConsumerSetMonitor");

  }