docs: public void setAsynchConsumer(AsynchConsumerCallback consumer,
                                   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, "setAsynchConsumer",
                                             new Object[]
                                             {
                                                consumer,
                                                maxActiveMessages,
                                                messageLockExpiry,
                                                maxBatchSize,
                                                orderContext,
                                                maxSequentialFailures,                                    //SIB0115d.comms
                                                hiddenMessageDelay,
                                                stoppable                                                         //472879
                                             });
  
        if (sessionId == 0)
        {
           // If the session Id = 0, then no one called setSessionId(). As such we are unable to flow
           // to the server as we do not know which session to instruct the server to use.
           SIErrorException e = new SIErrorException(
              nls.getFormattedMessage("SESSION_ID_HAS_NOT_BEEN_SET_SICO1043", null, null)
           );
  
           FFDCFilter.processException(e, CLASS_NAME + ".setAsyncConsumer",
                                       CommsConstants.CONVERSATIONHELPERIMPL_02, this);
  
           if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(this, tc, "Session Id was 0", e);
  
           throw e;
        }
  
        CommsByteBuffer request = getCommsByteBuffer();
        // Connection object id
        request.putShort(connectionObjectId);
        // Consumer session id
        request.putShort(sessionId);
        // Now put the message order context id if we have one
        if (orderContext != null)
        {
           request.putShort(((OrderingContextProxy)orderContext).getId());
        }
        else
        {
           request.putShort(CommsConstants.NO_ORDER_CONTEXT);
        }
        // Client session id - this is the proxy queue ID
        request.putShort(proxyQueueId);
        // Max active messages
        request.putInt(maxActiveMessages);
        // Message lock expiry
        request.putLong(messageLockExpiry);
        // Max batch size
        request.putInt(maxBatchSize);
  
        // If callback is Stoppable then send maxSequentialFailures & hiddenMessageDelay then change the
        // Segment Id to Stoppable  SIB0115d.comms
        int JFapSegmentId = JFapChannelConstants.SEG_REGISTER_ASYNC_CONSUMER;                             //SIB0115d.comms
  
        if (stoppable) {                                                                           //SIB0115d.comms,472879
          request.putInt(maxSequentialFailures);                                                          //SIB0115d.comms
          request.putLong(hiddenMessageDelay);
          JFapSegmentId = JFapChannelConstants.SEG_REGISTER_STOPPABLE_ASYNC_CONSUMER;                     //SIB0115d.comms
        }                                                                                                 //SIB0115d.comms
  
        CommsByteBuffer reply = null;
        try
        {
           // Pass on call to server
           reply = jfapExchange(request,
                                JFapSegmentId,                                                            //SIB0115d.comms
                                JFapChannelConstants.PRIORITY_MEDIUM,
                                true);
        }
        catch (SIConnectionLostException e)
        {
           // No FFDC Code needed
           // Converting this to a connection dropped as that is all we can throw
           if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(this, tc, "Connection was lost", e);
  
           throw new SIConnectionDroppedException(e.getMessage(), e);
        }
  
        // Confirm appropriate data returned
        try
        {
           short err = reply.getCommandCompletionCode(JFapChannelConstants.SEG_REGISTER_ASYNC_CONSUMER_R);
           if (err != CommsConstants.SI_NO_EXCEPTION)
           {
              checkFor_SISessionUnavailableException(reply, err);
              checkFor_SISessionDroppedException(reply, err);
              checkFor_SIConnectionUnavailableException(reply, err);
              checkFor_SIConnectionDroppedException(reply, err);
              checkFor_SIIncorrectCallException(reply, err);
              checkFor_SIErrorException(reply, err);
              defaultChecker(reply, err);
           }
        }
        finally
        {
           if (reply != null) reply.release();
        }
  
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "setAsynchConsumer");
     }