docs: public List<TickRange> sendValueMessages(
      List msgList,
      long completedPrefix,
      boolean requestedOnly,
      int priority,
      Reliability reliability,
      SIBUuid12 streamId)   // not used for ptp
      throws SIResourceException
    {
      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
        SibTr.entry(tc, "sendValueMessages",
          new Object[] { msgList,
                         new Long(completedPrefix),
                         targetMEUuid });
  
      JsMessage jsMsg = null;
          
      TickRange tickRange = null;
      MessageItem msgItem = null;
      long msgId = -1;
      List<TickRange> expiredMsgs = null;
  
      for (int i = 0; i < msgList.size(); i++)
      {
        tickRange = (TickRange)msgList.get(i);
        msgId = tickRange.itemStreamIndex;
  
        msgItem = getValueMessage(msgId);
   
        // If the message could not be found on the ItemStream then
        // we asume that it has expired  
        boolean removeMessage = false;
        if ( msgItem == null )
        {
          removeMessage = true;   
        }
        else
        {
          // Attempt to lock the message
          // This will fail if the message has already expired
          // or if it is already locked
          try
          {
            if ( !(msgItem.lockItemIfAvailable(lockID)) )
            {
              // Check whether message is already locked, as if this is a resend
              // after a Nack then it may be
              if ( !msgItem.isLocked() )
              {
                removeMessage = true;
              }
            }
          }
          catch (MessageStoreException e)
          {
            // FFDC
            FFDCFilter.processException(
              e,
              "com.ibm.ws.sib.processor.impl.PtoPOutputHandler.sendValueMessages",
              "1:1016:1.241",
              this);
              
            SibTr.exception(tc, e);
            
            if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
              SibTr.exit(tc, "sendValueMessages", e);
            
            throw new SIResourceException(e);          
          }
          
        }
              
        if( removeMessage )
        {      
          if ( expiredMsgs == null )
            expiredMsgs = new ArrayList<TickRange>();
          
          expiredMsgs.add(tickRange);   
  
          // In this case send Silence instead      
          ControlMessage cMsg = createSilenceMessage(tickRange.valuestamp,
                                                     completedPrefix,
                                                     priority,
                                                     reliability,
                                                     streamId);
                            
          if( isLink )
            cMsg = addLinkProps(cMsg);                             
          
          if( this.isSystemOrTemp )
            cMsg.setRoutingDestination(routingDestination); 
              
          // Send at priority+1 if this is a response to a Nack
          if( requestedOnly )
            mpio.sendToMe(routingMEUuid, priority+1, cMsg);
          else
            mpio.sendToMe(routingMEUuid, priority, cMsg);
                    
        }
        else
        {
          // Retrieve message from MessageItem
          jsMsg = msgItem.getMessage();
  
          // Modify the streamId if necessary     
          if( jsMsg.getGuaranteedStreamUUID() !=  streamId)
          {
            jsMsg.setGuaranteedStreamUUID(streamId);
          }
  
          // Modify the targetMEUuid if necessary     
          if( jsMsg.getGuaranteedTargetMessagingEngineUUID().equals(unknownUuid) )
          {
            jsMsg.setGuaranteedTargetMessagingEngineUUID(targetMEUuid);
          }
  
          // Are there Completed ticks after this Value
          // If so we need to adjust the message to reflect this
          if (tickRange.endstamp > tickRange.valuestamp)
          {
            jsMsg.setGuaranteedValueEndTick(tickRange.endstamp);
          }
  
          // Update the completedPrefix to current value
          jsMsg.setGuaranteedValueCompletedPrefix(completedPrefix);
  
          //Store in the message the amount of time it was on the queue
          long waitTime = msgItem.updateStatisticsMessageWaitTime();      
          jsMsg.setMessageWaitTime(waitTime);
                  
          // If the destination in a Link add Link specific properties to message
          if( isLink )
          {
            // Prevent any concurrent serialization of the JsMessage that could fail
            // due to having one property set but not the other
            synchronized(msgItem.getSynchUpdateLock())
            {
              jsMsg = addLinkProps(jsMsg);
            }
          }
          
          // As we're re-sending an existing message it'll probably already have a
          // routing destination in it if this is a system or temporary
          // destination so we shouldn't re-set it (in fact we can't
          // set one for tempQs as we don't know what the original one was
          // called as this PtoPOutputHandler will be the catch-all TDReceiver).
          // Defect 349843.
          if( this.isSystemOrTemp && (jsMsg.getRoutingDestination() == null))
          {
            jsMsg.setRoutingDestination(routingDestination);
          }
             
          if (TraceComponent.isAnyTracingEnabled() && UserTrace.tc_mt.isDebugEnabled())
            UserTrace.traceOutboundSend(jsMsg, 
                                       routingMEUuid, 
                                       destinationHandler.getName(),
                                       destinationHandler.isForeignBus() || destinationHandler.isLink(),
                                       destinationHandler.isMQLink(),
                                       destinationHandler.isTemporary());
             
          // Send message to destination
          // Using MPIO
          // Send at priority+1 because this is a resend after a Nack
          if( requestedOnly )
            mpio.sendToMe(routingMEUuid, priority+1, jsMsg);
          else
            mpio.sendToMe(routingMEUuid, priority, jsMsg);         
        }
      }
  
      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
        SibTr.exit(tc, "sendValueMessages", expiredMsgs);
        
      return expiredMsgs;  
    }