Add a new consumer to this set.

@param lcp
961007
public void addConsumer(DispatchableConsumerPoint lcp)
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(tc, "addConsumer", lcp);

    // WARNING: We mustn't hold the LCP lock of the consumer at this point
    synchronized(consumerList)
    {
      consumerList.add(lcp);
    }
    
    if(TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "addConsumer");

  }
1029476
private void addConsumerToRegisteredMonitorMap(
    MonitoredConsumer mc,
    ArrayList monitorList,
    Map registeredMonitors)
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
        SibTr.entry(
          tc,
          "addConsumerToRegisteredMonitorMap",
          new Object[] { registeredMonitors,
                         mc,
                         monitorList });
    // Finally, add this consumer to the appropriate places in the registered
    // consumer monitors tables
    Iterator i = monitorList.iterator();
    while (i.hasNext())
    {
      String tExpr = (String)i.next();

      // Get the next monitor
      RegisteredCallbacks rMonitor = (RegisteredCallbacks)registeredMonitors.get(tExpr);

      // Retrieve the current list of consumers
      ArrayList matchingConsumerList = rMonitor.getMatchingConsumers();

      // There is no need to drive any callbacks as we are placing subscriptions
      // in the registrations table that correspond to existing subscriptions.
      // So simply add the new subscription to the list.
      matchingConsumerList.add(mc);
    }

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

  }
1221376
@Nonnull
	public static <T> SupplierBuilder<T> supplier(Consumer<Supplier<T>> consumer) {
		return new SupplierBuilder(consumer);
	}
21270
public Consumer<AppendGroupOp> asAppendGroupConsumer() {
        return new Consumer<AppendGroupOp>() {
            @Override
            public void accept(AppendGroupOp op) throws Exception {
                appendWith(op.getArg1());
            }
        };
    }
810855
public JMProgressiveManager<T, R> registerCompletedConsumer(
			Consumer<JMProgressiveManager<T, R>> completedConsumer) {
		Optional.ofNullable(completedConsumerList)
				.orElseGet(() -> completedConsumerList = new ArrayList<>())
				.add(completedConsumer);
		return this;
	}
470971
public void add(IConverter converter, Object sourceObject,
			TypeReference<?> destinationType, Object convertedObject) {
		convertedObjects.put(new ConvertedObjectsKey(converter, sourceObject,
				destinationType), convertedObject);
	}
945814
public void addComponent( BshClassPath bcp ) {
        if (bcp == null)
            return;
        if ( compPaths == null )
            compPaths = new ArrayList();
        compPaths.add( bcp );
        bcp.addListener( this );
    }
602503
public void add(T value) {
        Element<T> e = new Element<T>(value);
        queue.offer(e);
    }
673947
@SuppressWarnings("unchecked")
  void registerConsumer(Inspector<? super OutT> subInspector) {
    consumers.add((Inspector<OutT>) subInspector);
  }
202069
@Override
    public void registerAsynchConsumerCallback(
                                               AsynchConsumerCallback callback,
                                               int maxActiveMessages,
                                               long messageLockExpiry,
                                               int maxBatchSize,
                                               Reliability unrecoverableReliability,
                                               boolean inLine,
                                               OrderingContext context)
                    throws SISessionDroppedException, SISessionUnavailableException, SIErrorException, SIIncorrectCallException
    {
        if (TraceComponent.isAnyTracingEnabled() && CoreSPIConsumerSession.tc.isEntryEnabled())
            SibTr.entry(CoreSPIConsumerSession.tc, "registerAsynchConsumerCallback",
                        new Object[] { this,
                                      callback,
                                      new Integer(maxActiveMessages),
                                      new Long(messageLockExpiry),
                                      new Integer(maxBatchSize),
                                      unrecoverableReliability,
                                      Boolean.valueOf(inLine),
                                      context });

        //register the AsynchConsumer with the LCP
        _localConsumerPoint.registerAsynchConsumer(
                                                   callback,
                                                   maxActiveMessages,
                                                   messageLockExpiry,
                                                   maxBatchSize,
                                                   unrecoverableReliability,
                                                   inLine,
                                                   (OrderingContextImpl) context,
                                                   null // No callback busy lock is used for non-mediation consumers.
        );

        if (TraceComponent.isAnyTracingEnabled() && CoreSPIConsumerSession.tc.isEntryEnabled())
            SibTr.exit(CoreSPIConsumerSession.tc, "registerAsynchConsumerCallback");
    }
924451
@Override
    public void add(int arg0, Object arg1) {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            JmfTr.entry(this, tc, "add", new Object[] { Integer.valueOf(arg0), arg1 });

        synchronized (getMessageLockArtefact()) {
            super.add(arg0, arg1);
        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            JmfTr.exit(this, tc, "add");
    }
938328
@Indexable(type = IndexableType.REINDEX)
	@Override
	public CPInstance addCPInstance(CPInstance cpInstance) {
		cpInstance.setNew(true);

		return cpInstancePersistence.update(cpInstance);
	}
1346805
@Nonnull
	public static <T> LConsumer<T> consumerFrom(Consumer<LConsumerBuilder<T>> buildingFunction) {
		LConsumerBuilder builder = new LConsumerBuilder();
		buildingFunction.accept(builder);
		return builder.build();
	}
199227
public void registerConsumer( LocalMessageConsumer consumer )
    {
    	consumersLock.writeLock().lock();
    	try
    	{
    		localConsumers.add(consumer);
    	}
    	finally
    	{
    		consumersLock.writeLock().unlock();
    	}
    }
1174636
@Nonnull
	public static <T> LObjFltConsumerBuilder<T> objFltConsumer(Consumer<LObjFltConsumer<T>> consumer) {
		return new LObjFltConsumerBuilder(consumer);
	}
40243
void addConsumer(ConsumerSessionImpl consumer) {
        if (TraceComponent.isAnyTracingEnabled()
            && tc.isEntryEnabled())
            SibTr.entry(tc, "addConsumer", consumer);

        _consumerList.add(consumer);

        if (TraceComponent.isAnyTracingEnabled()
            && tc.isEntryEnabled())
            SibTr.exit(tc, "addConsumer");
    }
1045490
void addCallbacks(Consumer<? super T> successCallback, Consumer<Throwable> failureCallback, Executor executor) {
        Objects.requireNonNull(successCallback, "'successCallback' must not be null");
        Objects.requireNonNull(failureCallback, "'failureCallback' must not be null");
        Objects.requireNonNull(executor, "'executor' must not be null");

        synchronized (mutex) {
            state = state.addCallbacks(successCallback, failureCallback, executor);
        }
    }