docs: private void createLinkLocalization(
                                          VirtualLinkDefinition virtualLinkDefinition,
                                          LocalTransaction transaction) throws SIResourceException
      {
          if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
              SibTr.entry(tc, "createLinkLocalization", new Object[] { virtualLinkDefinition, transaction });
  
          boolean linkCreated = false;
          LinkHandler linkHandler = null;
  
          //Include links that are awaiting deletion as we may need to re-use their
          //stream state.
          LinkTypeFilter filter = new LinkTypeFilter();
          DestinationHandler dh = linkIndex.findByName(virtualLinkDefinition.getName(), filter);
  
          if (dh == null)
          {
              // Create a new LinkHandler, which is created locked
              linkHandler =
                              new LinkHandler(virtualLinkDefinition,
                                              messageProcessor,
                                              this,
                                              transaction,
                                              durableSubscriptions);
  
              linkCreated = true;
              // The link is localised here, set the isLocal flag.
              //TODO could we use a different flag to avoid confusion?
              linkHandler.setLocal();
  
              LinkIndex.Type type = new LinkIndex.Type();
              type.local = Boolean.TRUE;
              type.mqLink = Boolean.FALSE;
              type.remote = Boolean.FALSE;
              type.state = State.CREATE_IN_PROGRESS;
              linkIndex.put(linkHandler, type);
  
              linkHandler.registerControlAdapters();
          }
          else
          {
              linkHandler = (LinkHandler) dh;
          }
  
          // If the link is corrupt, do not attempt any update.
          if (!linkHandler.isCorruptOrIndoubt())
          {
              synchronized (linkHandler)
              {
                  //If we didnt just create the linkHandler and the one that already
                  //existed is for a different UUID, or there is already a localisation for
                  //the linkHandler on this ME, then this could be a problem and further
                  //tests are required.
                  if (!linkCreated)
                  {
                      //Use the existing linkHandler of the same name as the stream state associated with it needs
                      //to be associated with the new LinkHandler.  This is because the ME at the other end
                      //of the link in the other bus only knows the LinkHandler by name and cannot
                      //tell that it has been deleted and recreated, so could still be sending using the old
                      //stream state
  
                      synchronized (linkIndex) {
  
                          LinkIndex.Type type = null;
                          if (linkIndex.get(linkHandler.getUuid()) != null)
                          {
                              type = (LinkIndex.Type) linkIndex.getType(linkHandler);
                              linkIndex.remove(linkHandler);
                          }
                          else
                              type = new LinkIndex.Type();
  
                          linkHandler.updateUuid(virtualLinkDefinition.getUuid());
  
                          type.local = Boolean.TRUE;
                          type.remote = Boolean.FALSE;
                          type.mqLink = Boolean.FALSE;
                          type.state = State.ACTIVE;
  
                          // Alert the lookups object to handle the re-definition
                          linkIndex.put(linkHandler, type);
  
                          //Unset the "to-be-deleted" indicator
                          if (linkHandler.isToBeDeleted() || !linkHandler.getUuid().equals(virtualLinkDefinition.getUuid()))
                          {
                              linkHandler.setToBeDeleted(false);
                              linkIndex.cleanup(linkHandler);
                          }
                      }
  
                      linkHandler.updateLinkDefinition(virtualLinkDefinition, transaction);
                  }
  
                  //Get the uuid of the ME in the other bus from TRM, then
                  //create a transmit q to it, to store messages originated from
                  //this ME destined for the other bus
  
                  LinkSelection s = null;
                  LinkManager linkManager = messageProcessor.getLinkManager();
                  try
                  {
                      s = linkManager.select(linkHandler.getUuid());
                  } catch (LinkException e)
                  {
                      //Error during create of the link.  Trace an FFST.
                      FFDCFilter.processException(
                                                  e,
                                                  "com.ibm.ws.sib.processor.impl.DestinationManager.createLinkLocalization",
                                                  "1:6182:1.508.1.7",
                                                  this);
  
                      SibTr.exception(tc, e);
                      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
                          SibTr.exit(tc, "createLinkLocalization", e);
                      throw new SIResourceException(e);
                  }
  
                  SIBUuid8 localisingME = null;
                  SIBUuid8 routingME = null;
                  if (s != null)
                  {
                      localisingME = s.getInboundMeUuid();
                      routingME = s.getOutboundMeUuid();
                  }
                  else
                  {
                      localisingME = new SIBUuid8(SIMPConstants.UNKNOWN_UUID);
                      routingME = null;
                  }
  
                  if (linkCreated || !linkHandler.hasRemote()) //PK76306 - if we don't have a remote localisation then create one
                  {
                      linkHandler.addNewPtoPLocalization(true,
                                                         transaction,
                                                         localisingME,
                                                         null,
                                                         true);
                  }
                  else
                      linkHandler.updateLocalisationSet(localisingME, routingME);
  
              }
          }
  
          if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
              SibTr.exit(tc, "createLinkLocalization");
      }