docs: public void consumeMessages(LockedMessageEnumeration lme) {
          if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
              SibTr.entry(this, tc, "consumeMessages", lme);
  
          // Cancel the alarm - this has no effect if it
          // is already cancelled. Note this could be null
          // if there is a message available immediately and
          // the alarm has not had chance to be started yet
          if (alarm != null) {
              if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                  SibTr.debug(this, tc, "Cancelling the alarm: " + alarm.toString());
              alarm.cancel();
              if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                  SibTr.debug(this, tc, "Alarm cancelled");
          }
  
          // We need to perform this check here as it is possible that while we were cancelling the
          // alarm, the alarm was already processing. To guarentee integrity, we should check the
          // result of the synchronized isComplete() method to find out whether the alarm is or has
          // processed this receive request.
          // If we find the alarm has dealt with this we should ensure the message is unlocked so that
          // it can get redelivered to another suitable consumer.
          if (isComplete()) {
              if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                  SibTr.debug(this, tc, "This session has already consumed a message - not processing");
              // Make sure we unlock the message. Note there will only ever
              // be one here.
              try {
                  lme.nextLocked();
                  lme.unlockCurrent();
              } catch (SIException si) {
                  //No FFDC code needed
                  //Only FFDC if we haven't received a meTerminated event.
                  if (!((ConversationState) mainConsumer.getConversation().getAttachment()).hasMETerminated()) {
                      // Not a lot we can do with this
                      FFDCFilter.processException(si, CLASS_NAME + ".consumeMessages",
                                                  CommsConstants.CATSYNCASYNCHREADER_CONSUME_MSGS_04, this);
                  }
  
                  if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                      SibTr.debug(this, tc, si.getMessage(), si);
              }
  
              // NOTE: Early return
              if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
                  SibTr.exit(this, tc, "consumeMessages");
              return;
          }
  
          // Set the flag to say that we have got a message.
          // Do this because if this method gets called, this is the
          // end of the line - we either send a message or an exception
          // back. This will stop the timer expiring (and sending a message)
          // while we are sending the message.
          setComplete(true);
  
          // Stop the session
          try {
              if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                  SibTr.debug(this, tc, "Stopping the session");
              stopSession();
              if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                  SibTr.debug(this, tc, "Session stopped");
          } catch (SIException si) {
              //No FFDC code needed
              //Only FFDC if we haven't received a meTerminated event.
              if (!((ConversationState) mainConsumer.getConversation().getAttachment()).hasMETerminated()) {
                  FFDCFilter.processException(si, CLASS_NAME + ".consumeMessages",
                                              CommsConstants.CATSYNCASYNCHREADER_CONSUME_MSGS_01, this);
              }
              if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                  SibTr.debug(this, tc, si.getMessage(), si);
          }
  
          // Get the message
          try {
              JsMessage message = (JsMessage) lme.nextLocked();
  
              if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                  SibTr.debug(this, tc, "Received message", message);
  
              // Delete the message
              SITransaction siTran =
                              ((ServerLinkLevelState) conversation.getLinkLevelAttachment()).getTransactionTable().get(transaction);
  
              if (siTran != IdToTransactionTable.INVALID_TRANSACTION) {
                  lme.deleteCurrent(siTran);
              } else {
                  lme.unlockCurrent();
              }
  
              // Send the message back to the client
              sendMessageToClient(message);
  
              // Update the lowest message priority
              mainConsumer.setLowestPriority(JFapChannelConstants.getJFAPPriority(message.getPriority()));
          } catch (SIException si) {
              // We will only get an exception here if a core API
              // error is encountered. As such, flow that back to the calling
              // client and FFDC
  
              //No FFDC code needed
              //Only FFDC if we haven't received a meTerminated event.
              if (!((ConversationState) conversation.getAttachment()).hasMETerminated()) {
                  FFDCFilter.processException(si, CLASS_NAME + ".consumeMessages",
                                              CommsConstants.CATSYNCASYNCHREADER_CONSUME_MSGS_03, this);
              }
  
              if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                  SibTr.debug(this, tc, si.getMessage(), si);
  
              StaticCATHelper.sendExceptionToClient(si,
                                                    CommsConstants.CATSYNCASYNCHREADER_CONSUME_MSGS_03,
                                                    conversation, requestNumber);
          } finally {
              //We now no longer need a registered listener as the current synchronous receive is complete.
              try {
                  final MPConsumerSession mpSession = (MPConsumerSession) mainConsumer.getConsumerSession();
                  mpSession.getConnection().removeConnectionListener(this);
              } catch (SIException e) {
                  //No FFDC code needed
                  //Only FFDC if we haven't received a meTerminated event.
                  if (!((ConversationState) conversation.getAttachment()).hasMETerminated()) {
                      FFDCFilter.processException(e, CLASS_NAME + ".consumeMessages", CommsConstants.CATSYNCASYNCHREADER_CONSUME_MSGS_05, this);
                  }
  
                  if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                      SibTr.debug(this, tc, e.getMessage(), e);
  
                  //No need to send an exception back to the client in this case as we are only really performing tidy up processing.
                  //Also, if it is a really bad problem we are likely to have already send the exception back in the previous catch block.
              }
          }
  
          if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
              SibTr.exit(this, tc, "consumeMessages");
      }