docs: boolean processAttachedMsgs() throws SIResourceException, SISessionDroppedException
      {
          if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
              SibTr.entry(tc, "processAttachedMsgs", this);
  
          SIMPMessage msg = null;
  
          // Check if there is a message attached to this consumer, we synchronize to make sure we
          // pick up the current settings and not something from our memory cache (we also do this
          // before we check the keyGroup as that is also changed under this lock)
          this.lock();
          try
          {
              msg = getAttachedMessage();
          } finally
          {
              this.unlock();
          }
  
          // If we're a member of a group there may be a message attached to one of
          // the members other than us
          if (_keyGroup != null)
          {
              ConsumableKey attachedKey = _keyGroup.getAttachedMember();
  
              // Another member of the group has a message attached for it so let
              // them process it.
              if ((attachedKey != null) && (attachedKey != _consumerKey))
              {
                  if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
                      SibTr.exit(tc, "processAttachedMsgs");
  
                  return ((JSLocalConsumerPoint) attachedKey.getConsumerPoint()).processAttachedMsgs();
              }
          }
  
          //if we actually have a message attached, process it
          if (msg != null)
          {
              // Is it a MessageItem or an ItemReference?
              // Or bifurcatable: We can't do this if it's bifurcatable because the
              // bifurcated consumers need to be able to call readSet() on the LME and
              // get the message back, so we HAVE to add it to the real LME rather than
              // the SingleLockedMessageEnumeration.
              if (!_msgOnItemStream && !_bifurcatable)
              {
                  // As the message never got to the MS we won't get a callback to
                  // generate a COD from, instead we generate one now using the
                  // autoCommitTransaction
                  if (!msg.isItemReference() && msg.getReportCOD() != null)
                  {
                      ((MessageItem) msg).beforeCompletion(_autoCommitTransaction);
                  }
  
                  //if it is not on an itemStream then it is a single attached message.
                  //This means that it's not locked in the traditional msgStore sense but
                  //we can handle it as if it were because we should be the only ones to
                  //have a reference to it at the moment.
  
                  // Have to turn this into a LockedMessageEnumeration
                  // Use single unlocked Message version of LME
  
                  // We used the cached one if we have it
                  if (_singleLockedMessageEnum != null)
                      _singleLockedMessageEnum.newMessage(msg);
                  else
                      _singleLockedMessageEnum = new SingleLockedMessageEnumerationImpl(this, msg);
  
                  //initiate the callback via the AsynchConsumer wrapper
                  _asynchConsumer.processMsgs(_singleLockedMessageEnum, _consumerSession);
  
                  // Now that we've processed the message remove it from our active message
                  // count (if we're counting). We know we can always do it here because there's no
                  // chance of the consumer holding onto the message past exiting consumeMessages()
                  // as it's an unrecoverable message.
                  removeActiveMessages(1);
  
                  // Clear the message from the cached enum
                  _singleLockedMessageEnum.clearMessage();
              }
              else
              {
                  // Do we really need this message in the MS?
                  boolean isRecoverable = true;
                  if ((_unrecoverableOptions != Reliability.NONE) &&
                      (msg.getReliability().compareTo(_unrecoverableOptions) <= 0))
                      isRecoverable = false;
  
                  registerForEvents(msg);
  
                  //store a reference to the locked message in the LME
                  _allLockedMessages.addNewMessage(msg, _msgOnItemStream, isRecoverable);
  
                  //initiate the callback via the AsynchConsumer wrapper
                  _asynchConsumer.processMsgs(_allLockedMessages, _consumerSession);
  
                  _allLockedMessages.resetCallbackCursor();
              }
  
              // Now we've processed one message we better check to see if there is
              // someone waiting for the asynch lock
              if (_externalConsumerLock != null)
                  _interruptConsumer = _externalConsumerLock.isLockYieldRequested();
  
              //a message was delivered, return true
              if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
                  SibTr.exit(tc, "processAttachedMsgs", Boolean.TRUE);
              return true;
          }
  
          // no message was delivered, return false
          if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
              SibTr.exit(tc, "processAttachedMsgs", Boolean.FALSE);
          return false;
      }