docs: public void deleteDestinationLocalization(
                                                String destinationUuid,
                                                DestinationDefinition destinationDefinition,
                                                Set<String> queuePointLocalizingMEs) throws SINotPossibleInCurrentConfigurationException, SITemporaryDestinationNotFoundException, SIResourceException
      {
  
          if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
              SibTr.entry(
                          tc,
                          "deleteDestinationLocalization",
                          new Object[] { destinationUuid, destinationDefinition, queuePointLocalizingMEs });
  
          //The Uuid passed in should never be null, but rather than checking for null, we
          //just accept that a NullPointerException will be thrown.  If null is passed in,
          //its a problem in the admin component and not something the user can fix.
  
          BaseDestinationHandler destinationHandler = null;
  
          //The destination is being deleted on the local messaging engine.
          String messagingEngineName = messageProcessor.getMessagingEngineName();
          //SIBUuid messagingEngineUuid = messageProcessor.getMessagingEngineUuid();
          SIBUuid12 destUuid = new SIBUuid12(destinationUuid);
  
          DestinationTypeFilter filter = new DestinationTypeFilter();
          filter.ALIAS = Boolean.FALSE;
          filter.FOREIGN_DESTINATION = Boolean.FALSE;
  
          DestinationHandler dh = destinationIndex.findByUuid(destUuid, filter);
  
          checkDestinationHandlerExists(
                                        dh != null,
                                        destinationUuid,
                                        messageProcessor.getMessagingEngineName());
  
          destinationHandler = (BaseDestinationHandler) dh;
          destinationHandler.getControlAdapter().deregisterControlAdapterMBean(); // to test
          // The lock order in this method is as follows:
          // 1) Take the lock on the destinationManager is taken to stop 2 threads creating the same
          //    destination and also to synchronize dynamic deletes with the
          //    creation of aliases.  This stops an alias destination being created that targets a
          //    destination in the process of being deleted.
          // 2) Lock the reallocation lock manager - see defect 331733
          // 3) Lock the destinationHandler
          //
          // We cannot call close on a producer while we have (3), because
          // the lock heirarchy requires the lock on a producer/consumer is taken before
          // the reallocation lock.
          // To reconcile this we take the following approach.
          // - Obtain all the locks, determine the deletion logic required, and mark toBeDeleted.
          // - Release all the locks and close the producers/consumers.
          // - Reestablish all the locks and complete the deletion logic.
  
          // Take locks to determine the deletion logic required
          boolean isDeletingEntireDestination;
          synchronized (this) // Lock1
          {
              // Lock2
              synchronized (destinationHandler.getMediationConsumerLockObject())
              {
                  LockManager reallocationLock = destinationHandler.getReallocationLockManager();
                  if (!destinationHandler.isPubSub())
                      reallocationLock.lockExclusive();
  
                  // Issue a try finally to ensure that lock manager is unlocked
                  try
                  {
                      synchronized (destinationHandler) // Lock4
                      {
                          // Check the destination still exists.
                          // This includes a check on the toBeDeleted flag, which is set in this
                          // block before we release any locks.
                          checkDestinationHandlerExists(
                                                        !(destinationHandler.isToBeDeleted()
                                                        || destinationHandler.isSystem()),
                                                        destinationHandler.getName(),
                                                        messageProcessor.getMessagingEngineName());
  
                          boolean destinationDefiniedLocally = destinationHandler.hasLocal();
  
                          //only allow this delete if the destination is defined locally or if the destination
                          //is a service
                          if (!destinationDefiniedLocally && !(destinationHandler.getDestinationType() == DestinationType.SERVICE))
                          {
                              /*
                               * The destination is not defined locally. Throw an
                               * exception.
                               */
                              if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
                                  SibTr.exit(
                                             tc,
                                             "deleteDestinationLocalization",
                                             "Destination not known " + destinationHandler.getName());
  
                              if (destinationHandler.isTemporary())
                              {
                                  if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
                                      SibTr.exit(tc, "deleteDestinationLocalization", "SITemporaryDestinationNotFoundException");
                                  throw new SIMPTemporaryDestinationNotFoundException(nls.getFormattedMessage(
                                                                                                              "DESTINATION_INSTANCE_NOT_FOUND_ERROR_CWSIP0042",
                                                                                                              new Object[] { destinationHandler.getName(), messagingEngineName },
                                                                                                              null));
                              }
  
                              if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
                                  SibTr.exit(tc, "deleteDestinationLocalization", "SINotPossibleInCurrentConfigurationException");
                              throw new SINotPossibleInCurrentConfigurationException(
                                              nls.getFormattedMessage(
                                                                      "DESTINATION_INSTANCE_NOT_FOUND_ERROR_CWSIP0042",
                                                                      new Object[] { destinationHandler.getName(), messagingEngineName },
                                                                      null));
                          }
  
                          // If the destinationDefinition is null, then the entire destination
                          // is being deleted, otherwise only this localisation of the
                          // destination is being deleted.
                          isDeletingEntireDestination =
                                          (destinationDefinition == null)
                                                          || (queuePointLocalizingMEs == null)
                                                          || (queuePointLocalizingMEs.size() == 0);
  
                          // If we are deleting the whole destination, then we mark
                          // the destination handler to be deleted, preventing any
                          // other thread from duplicating our work.
                          // This prevents consumers from attaching (attachConsumerPoint in ConsumerManager)
                          // However, it does not prevent producers from attaching. See comments below
                          if (isDeletingEntireDestination)
                          {
                              // We need to ensure that if the cleanupBaseDestintaion method
                              // is active on the async deletion thread, it does not perform the
                              // delete of our msgstore data until this method is complete.
                              destinationHandler.setDeleteInProgress(true);
                              destinationHandler.setToBeDeleted(true);
                          }
                      } // Lock4
                  } finally
                  {
                      // Unlock the reallocation LM
                      if (!destinationHandler.isPubSub())
                          reallocationLock.unlockExclusive(); // Lock3
                  }
              } // Lock 2
          } // Lock1
  
          // If we have determined that the whole destination is to be deleted,
          // then we need to close all active producers and consumers before
          // we make the destination eligible for deletion by the asynch deletion thread.
          if (isDeletingEntireDestination)
          {
              // The logic inside closeProducers has synchronized logic that ensures no
              // new producers can attach after this call completes (producers do not check isToBeDeleted)
              destinationHandler.closeProducers();
              // The list of consumers cannot change after the destination handler is marked
              // to be deleted (note this flag has been made volatile).
              destinationHandler.closeConsumers();
          }
  
          // Reestablish the locks to complete the deletion logic
          synchronized (this) // Lock1
          {
              // Lock2
              LockManager reallocationLock = destinationHandler.getReallocationLockManager();
              if (!destinationHandler.isPubSub())
                  reallocationLock.lockExclusive();
  
              // Issue a try finally to ensure that lock manager is unlocked
              try
              {
                  synchronized (destinationHandler) // Lock4
                  {
                      // Complete the required deletion logic
                      if (isDeletingEntireDestination)
                      {
                          // Set the deletion flag in the DH persistently
                          // (we marked toBeDeleted nonpersistently above)
                          ExternalAutoCommitTransaction transaction = txManager.createAutoCommitTransaction();
  
                          if (!dh.isTemporary() && !dh.isSystem())
                              SibTr.info(tc, "LOCAL_DEST_DELETE_INFO_CWSIP00217",
                                         new Object[] { dh.getName() });
  
                          // Change the state of the destination to make it eligible for
                          // deletion, but do not allow the async deletion thread to pick
                          // it up until our processing is complete (and we have released our locks)
                          destinationIndex.delete(destinationHandler);
                          try
                          {
                              destinationHandler.requestUpdate(transaction);
                          } catch (MessageStoreException e)
                          {
                              // MessageStoreException shouldn't occur so FFDC.
                              FFDCFilter.processException(
                                                          e,
                                                          "com.ibm.ws.sib.processor.impl.DestinationManager.deleteDestinationLocalization",
                                                          "1:3152:1.508.1.7",
                                                          this);
  
                              SibTr.exception(tc, e);
                              if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
                                  SibTr.exit(tc, "deleteDestinationLocalization", "SIResourceException");
                              throw new SIResourceException(e);
                          }
  
                          //Add all the localisations to the set of those requiring clean-up
                          destinationHandler.addAllLocalisationsForCleanUp();
  
                          //Clear the set of ME's that localise the destination
                          destinationHandler.clearLocalisingUuidsSet();
  
                          //Delete all aliases that target this destination
                          destinationHandler.deleteTargettingAliases();
                      }
                      else
                      {
                          // Only this localisation being deleted.  There should be other
                          // localisations for the destination that are still available.
                          destinationHandler.updateLocalizationSet(
                                          queuePointLocalizingMEs);
  
                          //      Alert the lookups object to handle the re-definition
                          destinationIndex.setLocalizationFlags(destinationHandler);
  
                          // The attributes of the destinationDefinition may also have
                          // changed.  These need to be updated.
                          destinationHandler.updateDefinition(destinationDefinition);
  
                          destinationIndex.cleanup(destinationHandler);
                      }
                      // PM71953 - deregister destination from WLM before actual destination cleanup. When there
                      // are frequent destination deletion and recreation (with the same name), it is possible that
                      // the recreated destination gets deregistered from WLM instead of the destination that has
                      // been marked for deletion, this is because WLM registers/deregisters destination by destination
                      // name and not by UUID.
                      //
                      // The deregister code during cleanup destination task (by AsynchDeletionThread) is not removed
                      // in this APAR due to other dependencies. So there are two attempts to deregister the same
                      // destination. However, once deregistered, further deregister attempts for the same destination
                      // will be safely ignored.
                      destinationHandler.deregisterDestination();
                  } // Lock4
              } finally
              {
                  // Unlock the reallocation LM
                  if (!destinationHandler.isPubSub())
                      reallocationLock.unlockExclusive(); // Lock3
              }
          } // Lock1
  
          // Make the destination eligible for deletion, then poke the asynchronous
          // deletion thread. We only use the destination handler lock here
          // (sync'd method), to avoid any interactions with locking that might
          // be performed on the asynchronous deletion thread.
          if (isDeletingEntireDestination)
          {
              destinationHandler.setDeleteInProgress(false);
  
              // Now start the asynch deletion thread
              startAsynchDeletion();
          }
  
          if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
              SibTr.exit(tc, "deleteDestinationLocalization");
  
          return;
      }