docs: @Override
      public void registerStoppableAsynchConsumer(
                                                  StoppableAsynchConsumerCallback callback,
                                                  int maxActiveMessages,
                                                  long messageLockExpiry,
                                                  int maxBatchSize,
                                                  Reliability unrecoverableReliability,
                                                  boolean inLine,
                                                  OrderingContextImpl orderingGroup,
                                                  ExternalConsumerLock optionalCallbackBusyLock,
                                                  int maxSequentialFailures,
                                                  long hiddenMessageDelay)
                      throws SISessionUnavailableException, SISessionDroppedException,
                      SIErrorException,
                      SIIncorrectCallException
      {
          if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
              SibTr.entry(
                          tc,
                          "registerStoppableAsynchConsumer",
                          new Object[] {
                                        this,
                                        callback,
                                        Integer.valueOf(maxActiveMessages),
                                        Long.valueOf(messageLockExpiry),
                                        Integer.valueOf(maxBatchSize),
                                        unrecoverableReliability,
                                        Boolean.valueOf(inLine),
                                        orderingGroup,
                                        optionalCallbackBusyLock,
                                        maxSequentialFailures,
                                        hiddenMessageDelay });
  
          try
          {
              this.lock();
              {
                  _maxSequentialFailuresThreshold = maxSequentialFailures;
  
                  // If message ordering is required or if no exception destination has been specified, then any 
                  // positive value for the threshold should be set to one, so that a consumer will be stopped 
                  // as soon as the first message hits its redelivery limit
                  if (_destinationAttachedTo.isOrdered() ||
                      (_destinationAttachedTo.getExceptionDestination() == null) ||
                      (_destinationAttachedTo.getExceptionDestination().equals("")))
                  {
                      if (_maxSequentialFailuresThreshold > 0)
                      {
                          if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                              SibTr.debug(tc, "Setting maxSequentialMessageThreshold to 0");
  
                          _maxSequentialFailuresThreshold = 1;
                      }
                  }
  
                  if (_maxSequentialFailuresThreshold <= 0)
                  {
                      // if the max sequential failure threshold is zero or less then the consumer
                      //  will never be stopped so we don't want to hide messages
                      _consumerStoppable = false;
                      _hiddenMessageDelay = 0;
                  }
                  else
                  {
                      _consumerStoppable = true;
                      _hiddenMessageDelay = hiddenMessageDelay;
                  }
              }
          } finally
          {
              this.unlock();
          }
  
          registerAsynchConsumer(callback, maxActiveMessages, messageLockExpiry, maxBatchSize, unrecoverableReliability, inLine, orderingGroup, optionalCallbackBusyLock);
  
          if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
              SibTr.exit(tc, "registerStoppableAsynchConsumer");
      }