docs: private void eventPostAdd(SIMPMessage msg,
                              TransactionCommon transaction,
                              boolean rollback) throws SIResourceException
    {
      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
        SibTr.entry(tc, "eventPostAdd", new Object[]{msg,transaction,new Boolean(rollback)});
       
      JsMessage jsMsg = msg.getMessage();
      boolean sendMessage = false;
      
      if(rollback)
      {
        sendMessage = rollbackInsert((MessageItem)msg);
      }
      else
      {
        sendMessage = commitInsert((MessageItem)msg);
      }
      
      // A message is now committed to sourceStream. Run reallocation if 
      // reallocator was running while the message was committing. Also
      // don`t send the message.
      if (isReallocationRequired(msg))
      {
        ((BaseDestinationHandler)destinationHandler).requestReallocation();
        sendMessage = false;      
      }
      
      // sendMessage will be true unless the message is beyond the inDoubt window
      // or we have guessed that this is the correct stream to use and 
      // had to move the message because WLM told us to.
      if( sendMessage && !rollback )
      {
        // If this is a message not silence then
        // attempt to lock the message to prevent expiry
        // as we are about to send it now
        boolean msgLocked = false;
        try
        {
          msgLocked = msg.lockItemIfAvailable(lockID);
  
          // It's just possible that a Nack has come in for this message before we've
          // even sent it (because there are load's of producers concurrently sending in
          // messages, which really srews around the order of the messages!). In that
          // case the message would already be locked, but by the nack processing, not us.
          // Either way, we need to keep the message.
          if(!msgLocked && msg.isLocked() )
          {
            msgLocked = true;
          }
          	
        }
        catch(MessageStoreException e)
        {
          // FFDC
          FFDCFilter.processException(
              e,
              "com.ibm.ws.sib.processor.impl.PtoPOutputHandler.eventPostAdd",
              "1:1438:1.241",
              this);  
                      
          SibTr.exception(tc, e); 
          
          // Leave the msg where it is and throw exception 
          if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(tc, "eventPostAdd", e);
          
          throw new SIResourceException(e);
        }
        
        if (!msgLocked)
        {
          // We failed to lock the message so it must have already expired or been
          // deleted already, call removeMessage, which will try to remove the message
          // or tell us that the message has already been removed
          boolean msgRemoved = sourceStreamManager.removeMessage(msg);
          
          // If we've just removed the message then we better send a silence in its place
          if(msgRemoved)
            rollback = true;
          // Otherwise, someone else has removed it, probably because they've already processed
          // it, so we should do nothing with it.
          else
            sendMessage = false;
        }
      }
            
      // In this case send Silence instead      
      if( sendMessage )  
      {
        if( rollback )
        {  
          ControlMessage cMsg = createSilenceMessage(jsMsg.getGuaranteedValueValueTick(),
                                                     jsMsg.getGuaranteedValueCompletedPrefix(),
                                                     msg.getPriority(),
                                                     msg.getReliability(),
                                                     msg.getMessage().getGuaranteedStreamUUID());    
        
          // If the destination in a Link add Link specific properties to message
          if( isLink )
          {
            cMsg = addLinkProps(cMsg);
          }
          
          mpio.sendToMe(
              routingMEUuid,
                 cMsg.getPriority().intValue(),
                 cMsg);
        }  
        else
        {
          // 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(((MessageItem)msg).getSynchUpdateLock())
            {
              jsMsg = addLinkProps(jsMsg);
            }
          }
            
          //Store in the message the amount of time it was on the queue
          long waitTime = msg.updateStatisticsMessageWaitTime();      
          jsMsg.setMessageWaitTime(waitTime);
        
          if (TraceComponent.isAnyTracingEnabled() && UserTrace.tc_mt.isDebugEnabled())
            UserTrace.traceOutboundSend(jsMsg, 
                                       routingMEUuid,
                                       destinationHandler.getName(),
                                       destinationHandler.isForeignBus() || destinationHandler.isLink(),
                                       destinationHandler.isMQLink(),
                                       destinationHandler.isTemporary());
  
          //  Send message using MPIO
          mpio.sendToMe(
              routingMEUuid,
              jsMsg.getPriority().intValue(),
              jsMsg);
          
          // We have sent the msg over the wire so we can now drop the jsmessage for
          // now so that we don't keep it is memory for to long
          msg.releaseJsMessage();
          
        }
      }
      
      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
        SibTr.exit(tc, "eventPostAdd");
    }