docs: public SIBUuid8 updateLocalisationSet(SIBUuid8 newLocalisingMEUuid,
                                               SIBUuid8 newRoutingMEUuid) 
      throws  SIResourceException 
    {
      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
        SibTr.entry(tc, 
                    "updateLocalisationSet", 
                    new Object[] {newLocalisingMEUuid, 
                                  newRoutingMEUuid});
      // Create a local UOW
      LocalTransaction transaction = _baseDestinationHandler.
                                               getTransactionManager().
                                               createLocalTransaction(false);
      Transaction msTran = _messageProcessor.resolveAndEnlistMsgStoreTransaction(transaction);
      boolean rollback = true; // Assume the worse
  
      SIBUuid8 existingUuid = null;
      
      try
      {
        synchronized(_localisationManager.getAllXmitQueuePoints())
        {
          HashMap validXmits = new HashMap();
          Iterator it = _localisationManager.getAllXmitQueuePoints().values().iterator();
          while (it.hasNext())
          {
            PtoPXmitMsgsItemStream xmit = (PtoPXmitMsgsItemStream)it.next();
            if (xmit.isToBeDeleted())
              _deletedQueuePoints.put(xmit.getLocalizingMEUuid(), xmit);
            else
              validXmits.put(xmit.getLocalizingMEUuid(), xmit);
          }
      
          //Validity check - there should only by one existing localisation
          if (validXmits.size() > 1 || 
             (validXmits.size() > 0) && (_pToPLocalMsgsItemStream != null))
          {
            if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
              SibTr.exit(tc, "updateLocalisationSet");
            
            SibTr.error(tc, "INTERNAL_MESSAGING_ERROR_CWSIP0001",
              new Object[] {
                "com.ibm.ws.sib.processor.impl.LinkHandler",
                "1:302:1.21"});
              
            throw new SIErrorException(nls.getFormattedMessage(
              "INTERNAL_MESSAGING_ERROR_CWSIP0001",
              new Object[] {
                "com.ibm.ws.sib.processor.impl.destination.LinkState",
                "1:308:1.21"},
              null));        
          }
          
          //Is there a localisation for the new MEUuid that is in the process of
          //being deleted?
          PtoPMessageItemStream deletingItemStream = (PtoPMessageItemStream) _deletedQueuePoints.get(newLocalisingMEUuid);
          if ((deletingItemStream != null) &&
              (!(deletingItemStream.isInStore())))
          {
            //There was an old queuepoint but its no longer in the messagestore, so it
            //has been deleted and we can create a new one instead
            deletingItemStream = null;
          }
  
          if (validXmits.size() == 0 && _pToPLocalMsgsItemStream == null)
          {
            //There are no live localisations.  Is there one in deleting state?
            if (deletingItemStream != null)
            {
              deletingItemStream.unmarkAsToBeDeleted(msTran);
              _deletedQueuePoints.remove(newLocalisingMEUuid);
                
              _localisationManager.
                attachRemotePtoPLocalisation(deletingItemStream,
                                             _remoteSupport);
  
              assignQueuePointOutputHandler(deletingItemStream.getOutputHandler(), 
                                            newLocalisingMEUuid); 
            }
            else
            {
              // No localisations existed.  Create the new one
              PtoPMessageItemStream newStream = 
                _localisationManager.addNewRemotePtoPLocalization(transaction, 
                                                                newLocalisingMEUuid,
                                                                null,
                                                                true,
                                                                _remoteSupport);              
              ((PtoPOutputHandler)newStream
                .getOutputHandler())
                .updateRoutingCellule(newRoutingMEUuid);
            }
          }
          else
          {
            //Get the existing uuid
            
            PtoPMessageItemStream ptoPMessageItemStream = null;
            
            // If a local itemstream exists then we are an MQLink that is localised on this ME
            // Therefore dont bother to update state.
            if (_pToPLocalMsgsItemStream == null)
            {
              Iterator transmitQueueIterator = 
                validXmits.values().iterator(); 
  
              ptoPMessageItemStream = (PtoPMessageItemStream) transmitQueueIterator.next();
            
            
              PtoPOutputHandler outputHandler = (PtoPOutputHandler)ptoPMessageItemStream.getOutputHandler();
              existingUuid = ptoPMessageItemStream.getLocalizingMEUuid(); 
  
              //Its possible that we dont know the uuid of the localising ME at the other
              //end of the link, as its in another bus so we rely on TRM to get it for us.
              //In this case, the UUID constant UNKNOWN_UUID is used.
              if (newLocalisingMEUuid.toString().equals(SIMPConstants.UNKNOWN_UUID)) 
                   
              {
                // localisingMe is unknown - dont do anything
              }
              else if (existingUuid.equals(newLocalisingMEUuid) || 
                        existingUuid.equals(new SIBUuid8(SIMPConstants.UNKNOWN_UUID)))
              {
                //The existing localisation has the UNKNOWN_UUID constant, but the
                //localisation being passed in has a real uuid, so the existing 
                //localisation should be updated to use the real uuid.
                ptoPMessageItemStream.replaceUuid(newLocalisingMEUuid, msTran);
                
                //Update the localisation in the hashSets
                _localisationManager.removeXmitQueuePoint(existingUuid);
                _localisationManager.addXmitQueuePoint(
                  newLocalisingMEUuid, ptoPMessageItemStream);
  
                outputHandler.updateTargetCellule(newLocalisingMEUuid);
  
                //Update the outputhandler lookup
                _localisationManager.
                  updateQueuePointOutputHandler(newLocalisingMEUuid, 
                                                outputHandler,
                                                existingUuid);
              }
              else
              {
                // The localisation of the link has moved.  Add in the new localisation
                // and delete the old one.
  
                //Is there an instance of the localisation in deleting state?
                if (deletingItemStream != null)
                {
                  deletingItemStream.unmarkAsToBeDeleted(msTran);
                  _deletedQueuePoints.remove(newLocalisingMEUuid);
                  
                  _localisationManager.addXmitQueuePoint(
                    deletingItemStream.getLocalizingMEUuid(),
                    deletingItemStream);
                  
                  assignQueuePointOutputHandler(deletingItemStream.getOutputHandler(), 
                                                newLocalisingMEUuid);  
                }
                else
                {
                  PtoPMessageItemStream newStream = 
                    _localisationManager.addNewRemotePtoPLocalization(transaction, 
                                         newLocalisingMEUuid,
                                         null,
                                         true,
                                         _remoteSupport);
                  
                  ((PtoPOutputHandler)newStream
                      .getOutputHandler())
                      .updateRoutingCellule(newRoutingMEUuid);
                }                
                
                // 176658.3.3
                transaction.registerCallback(
                    _localisationManager.new LocalizationRemoveTransactionCallback(ptoPMessageItemStream));
  
                 
                // Mark the localisation for deletion
                ptoPMessageItemStream.markAsToBeDeleted(msTran);
                
                //Remember the deleted localisation incase we need to reincarnate it.
                //This is a behaviuor reserved for links.  Because the other end of the
                //link is in another bus and wont know if this end of the link is deleted,
                //it will still be using the stream state associated with this link,
                //so if at a future point the link is recreated to the same ME, we should
                //use the same stream state if we can.
                _deletedQueuePoints.put(existingUuid, ptoPMessageItemStream);
                
                //Get the background clean-up thread to reallocate the messages and
                //clean up the localisation if possible.
                _destinationManager.markDestinationAsCleanUpPending(_baseDestinationHandler);
                
                // If the old link is localised to this ME then it'll have a proxy
                // pubsub neighbour setup, so we need to delete that. The easiest way to 
                // check is to see if a neighbour actually exists or not.
                if(_messageProcessor.getProxyHandler().getNeighbour(existingUuid, true) != null)
                {
                  try
                  {
                    //Cleanup the neighbours
                    _messageProcessor.getProxyHandler().deleteNeighbourForced(existingUuid, _baseDestinationHandler.getBus() , (Transaction)transaction);
                  }
                  catch (Exception e)
                  {
                    // As the neighbours aren't locked down there's a chance of a problem,
                    // but we'll report the error and carry on.
                    
                    // FFDC
                    FFDCFilter.processException(e, 
                                                "com.ibm.ws.sib.processor.impl.destination.LinkState.updateLocalisationSet", 
                                                "1:473:1.21", 
                                                this);
                    
                    if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                      SibTr.debug(tc, "Caught exception when deleting neighbour, however this is not always an issue as it might have already been removed: " + e);
                  }
                }
              }
              
              // Set the new routingCellule. Take into account the sending MEs that do not have
              // the link localised on their ME          
              if(newRoutingMEUuid != null)
              {
                // If link is localised here
                if (newRoutingMEUuid.equals(_messageProcessor.getMessagingEngineUuid()))
                  newRoutingMEUuid = newLocalisingMEUuid;
                
                outputHandler.updateRoutingCellule(newRoutingMEUuid);
              }
            }
          }
        }
        
        // We got through it without failing!
        rollback = false;
      }
      finally
      {
        //Commit the transaction outside of synchronisation of the linkHandler
        try 
        {
          if(rollback)
          {
            if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
              SibTr.debug(tc, "Update failed, transaction rolling back");
              
            transaction.rollback();
          }
          else
            transaction.commit();
        }
        catch (SIIncorrectCallException e)
        {
          // No FFDC code needed
          if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(tc, "updateLocalisationSet", e);
          throw new SIResourceException(e);
        }
      }
   
      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
        SibTr.exit(tc, "updateLocalisationSet", existingUuid);
      
      return existingUuid;
    }