docs: private void callDestinationListener(String destinationName) throws SIResourceException
      {
          if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
              SibTr.entry(tc, "callDestinationListener", new Object[] { destinationName });
  
          DestinationListenerDataObject listenerDataObject = null;
          DestinationListener destinationListener = null;
          DestinationAvailability listenersDestinationAvailability = null;
          SICoreConnection listenersConnection = null;
          DestinationNamePattern destinationNamePattern = null;
  
          BaseDestinationHandler destinationHandler = null;
  
          try
          {
              destinationHandler = (BaseDestinationHandler) getDestination(destinationName, false);
          } catch (SIMPDestinationCorruptException e)
          {
              FFDCFilter.processException(
                                          e,
                                          "com.ibm.ws.sib.processor.impl.DestinationManager.callDestinationListener",
                                          "1:7589:1.508.1.7",
                                          this);
  
              SibTr.exception(tc, e);
  
              if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
                  SibTr.exit(tc, "callDestinationListener", "Destination corrupt");
  
              // Finding that a restored destination has been marked as corrupt is no
              // reason to cause the transaction to fail.  Andrew Whitfield says that
              // a destination listener will not want to know about corrupt destinations
              // so we end up just returning.
              return;
          } catch (SIException e)
          {
              FFDCFilter.processException(
                                          e,
                                          "com.ibm.ws.sib.processor.impl.DestinationManager.callDestinationListener",
                                          "1:7608:1.508.1.7",
                                          this);
  
              SibTr.exception(tc, e);
              if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
                  SibTr.exit(tc, "callDestinationListener", "SIResourceException");
              throw new SIResourceException(e);
          }
  
          if (!(destinationHandler.definition.getDestinationType() == DestinationType.TOPICSPACE))
          {
  
              for (int i = 0; i < destinationListeners.size(); i++)
              {
                  listenerDataObject = destinationListeners.get(i);
                  destinationListener = listenerDataObject.getDestinationLister();
                  listenersDestinationAvailability = listenerDataObject.getDestinationAvailability();
                  listenersConnection = listenerDataObject.getConnection();
                  destinationNamePattern = listenerDataObject.getDestinationNamePattern();
  
                  SIDestinationAddress destinationAddress = null;
  
                  if (isAvailable(destinationHandler, listenersDestinationAvailability)
                      && (!(destinationHandler.isSystem()))
                      && listenerDataObject.getDestinationType() == destinationHandler.definition.getDestinationType())
                  {
                      // Check whether a destination name pattern was specified
                      if (destinationNamePattern == null || destinationNamePattern.match(destinationName))
                      {
                          // No pattern or the pattern matches the name.
                          destinationAddress =
                                          (
                                          (SIDestinationAddressFactory) MessageProcessor.getSingletonInstance(
                                                          SIMPConstants.SI_DESTINATION_ADDRESS_FACTORY)).createSIDestinationAddress(
                                                                                                                                    destinationHandler.getName(),
                                                                                                                                    true);
                          // call the listener
                          destinationListener.destinationAvailable(
                                                                   listenersConnection,
                                                                   destinationAddress,
                                                                   listenersDestinationAvailability);
                      }
                  }
              }
          }
          if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
              SibTr.exit(tc, "callDestinationListener");
      }