docs: private void _registerAsynchConsumerCallback(AsynchConsumerCallback callback,
                                                  int maxActiveMessages,
                                                  long messageLockExpiry,
                                                  int maxBatchSize,
                                                  OrderingContext orderContext,
                                                  int maxSequentialFailures,                              //SIB0115d.comms
                                                  long hiddenMessageDelay,
                                                  boolean stoppable)                                              //472879
        throws SISessionUnavailableException, SISessionDroppedException,
               SIConnectionUnavailableException, SIConnectionDroppedException,
               SIErrorException,
               SIIncorrectCallException
     {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "_registerAsynchConsumerCallback",
                                                                                     new Object[]
                                                                                     {
                                                                                        callback,
                                                                                        maxActiveMessages,
                                                                                        messageLockExpiry,
                                                                                        maxBatchSize,
                                                                                        orderContext,
                                                                                        maxSequentialFailures,
                                                                                        hiddenMessageDelay,
                                                                                        stoppable
                                                                                     });
  
        boolean completed = false;
  
        if (callback != null)
        {
           // Before we flow the register, ensure we increment the use count on the order context
           // if they passed one. This is to ensure one gets created if it does not exist
           // already.
           OrderingContextProxy oc = (OrderingContextProxy) orderContext;
  
           // Did they supply an ordering context for us to use?
           if (oc == null)
           {
              // If they did not, see if we already have an ordered async consumer registered, If so,
              // decrement the use count on the old order context and discard it.
              if (currentOrderingContext != null)
              {
                 currentOrderingContext.decrementUseCount();
                 currentOrderingContext = null;
              }
           }
           // They did supply an ordering context to use
           else
           {
              // Do we already have an un-ordered async consumer registered?
              // If so, we should increment the count on the new one.
              if (currentOrderingContext == null && asynchConsumerRegistered)
              {
                 oc.incrementUseCount();
              }
              else if (currentOrderingContext != null && asynchConsumerRegistered)
              {
                 // Do we already have an ordered async consumer registered?
                 if (oc == currentOrderingContext)
                 {
                    // Is it the same? If it is - do nothing.
                 }
                 else
                 {
                    // If it is not the same, decrement the old, and increment the new.
                    currentOrderingContext.decrementUseCount();
                    oc.incrementUseCount();
                 }
              }
              // Otherwise, new registration - so increment the use count
              else if (!asynchConsumerRegistered)
              {
                 oc.incrementUseCount();
              }
           }
  
           try
           {
              try
              {
                 if (isReadAhead)
                 {
                    if ((maxActiveMessages != 0) || (messageLockExpiry != 0) || (stoppable))                      //472879
                    {
                       if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled() && stoppable) { //SIB0115d.comms,472879
                         SibTr.debug(this, tc, "Forcing Read Ahead off because callback is Stoppable");   //SIB0115d.comms
                       }                                                                                  //SIB0115d.comms
  
                       // If we had a read ahead proxy queue and someone has attempted to
                       // register an asynchronous consumer with either maxActiveMessages
                       // or messageLockExpiry - trash the read ahead proxy queue and
                       // substitute it with an asynch proxy queue.  This is because we
                       // currently do not support these options on read ahead. Using a               s
                       // Stoppable callback also forced read ahead off.
                       short seqNumber = proxyQueue.getCurrentMessageBatchSequenceNumber();
                       short id = proxyQueue.getId();
                       ProxyQueueConversationGroup pqcg =
                          ((ClientConversationState) getConversation().getAttachment()).getProxyQueueConversationGroup();
                       seqNumber++;
  
                       isReadAhead = false;
  
                       proxyQueue = pqcg.createAsynchConsumerProxyQueue(id, seqNumber, orderContext);
                       proxyQueue.setConsumerSession(this);
                       proxyQueue.setAsynchCallback(callback, maxActiveMessages, messageLockExpiry, maxBatchSize, orderContext, maxSequentialFailures, hiddenMessageDelay, stoppable); //SIB0115d.comms,472879
                    }
                    else
                    {
                       proxyQueue.setAsynchCallback(callback,
                                                    maxActiveMessages,
                                                    messageLockExpiry,
                                                    maxBatchSize,
                                                    null,
                                                    maxSequentialFailures,                                //SIB0115d.comms
                                                    hiddenMessageDelay,
                                                    stoppable);                                                   //472879
                    }
                 }
                 // If async proxy queue is not null, then we already have a callback registered
                 // and the caller would like to replace the callback or switch to / from
                 // ordered delivery
                 else if (proxyQueue != null) // No readahead
                 {
                    proxyQueue.setAsynchCallback(callback,
                                                 maxActiveMessages,
                                                 messageLockExpiry,
                                                 maxBatchSize,
                                                 orderContext,
                                                 maxSequentialFailures,                                   //SIB0115d.comms
                                                 hiddenMessageDelay,
                                                 stoppable);                                                      //472879
                 }
                 else // Create a new Proxy Queue
                 {
                    ClientConversationState clientConvState = (ClientConversationState) getConversation().getAttachment();
                    ProxyQueueConversationGroup pqcg = clientConvState.getProxyQueueConversationGroup();
                    if (pqcg == null)
                    {
                       ProxyQueueConversationGroupFactory pqFact = ProxyQueueConversationGroupFactory.getRef();
                       pqcg = pqFact.create(getConversation());
                       clientConvState.setProxyQueueConversationGroup(pqcg);
                    }
  
                    proxyQueue = pqcg.createAsynchConsumerProxyQueue(orderContext);
                    proxyQueue.setConsumerSession(this);
                    proxyQueue.setAsynchCallback(callback,
                                                 maxActiveMessages,
                                                 messageLockExpiry,
                                                 maxBatchSize,
                                                 orderContext,
                                                 maxSequentialFailures,                                   //SIB0115d.comms
                                                 hiddenMessageDelay,
                                                 stoppable);                                                      //472879
                 }
              }
              catch (SIResourceException e)
              {
                 // We failed to re-register the proxy queue. This could be because the call to create
                 // a proxy queue or destroy a proxy queue failed. We must rethrow this as an
                 // SIConnectionLostException as we will be unsure what the state of the system is
                 FFDCFilter.processException(e, CLASS_NAME + "._registerAsynchConsumerCallback",
                                             CommsConstants.CONSUMERSESSIONPROXY_REGASYNC_01, this);
  
                 if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(this, tc, "Caught a resource exception", e);
  
                 // And rethrow
                 throw new SIConnectionDroppedException(e.getMessage(), e);
              }
  
              completed = true;
  
              // And stash the order context in case we need it later
              currentOrderingContext = oc;
  
              asynchConsumerRegistered = true;
           }
           finally
           {
              // Ensure we decrement again if we failed
              if (!completed && oc != null) oc.decrementUseCount();
           }
        }
        else
        {
           // User supplied a null callback - this is the same as a de-reg
           deregisterAsynchConsumerCallback();
  
           // Ensure we decrement the count when we de-register
           if (currentOrderingContext != null)
           {
              currentOrderingContext.decrementUseCount();
  
              // And don't reference it anymore
              currentOrderingContext = null;
           }
        }
  
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "_registerAsynchConsumerCallback");
     }