docs: @Override
      public int checkAbleToAcceptMessage(JsDestinationAddress routingDestinationAddr) throws SIException
      {
          if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
              SibTr.entry(tc, "checkAbleToAcceptMessage", routingDestinationAddr);
  
          // Anything that isn't a link is let through as we would expect WLM to prevent
          // incoming messages once we're blocked (give or take a little latency)
  
          // Set the reason to OUTPUT_HANDLER_FOUND
          int blockingReason = DestinationHandler.OUTPUT_HANDLER_FOUND;
  
          //first we try to check if there is room on the actual destination
          //at the end of the link
          if (_isLink)
          {
              blockingReason = DestinationHandler.OUTPUT_HANDLER_NOT_FOUND;
  
              if (routingDestinationAddr != null)
              {
                  String destName = routingDestinationAddr.getDestinationName();
                  //always allow system or temporary destinations through
                  if (destName.startsWith(SIMPConstants.TEMPORARY_QUEUE_DESTINATION_PREFIX) ||
                      destName.startsWith(SIMPConstants.TEMPORARY_PUBSUB_DESTINATION_PREFIX) ||
                      destName.startsWith(SIMPConstants.SYSTEM_DESTINATION_PREFIX))
                  {
                      blockingReason = DestinationHandler.OUTPUT_HANDLER_FOUND;
                  }
  
                  //we need to look at the routing (target) destination first, to see if it's blocked
                  else
                  {
                      boolean checkedTarget = false;
                      try
                      {
                          // Can the routing destination or its exception destination accept a message
                          blockingReason =
                                          checkTargetAbleToAcceptOrExceptionMessage(routingDestinationAddr);
  
                          // We've checked the target and have a return code
                          checkedTarget = true;
                      } catch (SIMPNotPossibleInCurrentConfigurationException e)
                      {
                          // No FFDC code needed
  
                          // There's a problem with the configuration of the target destination - so set checkedTarget to
                          // true, retain the OUTPUT_HANDLER_NOT_FOUND return code and continue processing. If we find that
                          // the link exception destination is also unable to accept the message then we want to report
                          // the target blocking reason rather than the link blocking reason, which may be different.
                          checkedTarget = true;
  
                          // Log the exception
                          if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                              SibTr.exception(tc, e);
                      } catch (SIException e)
                      {
                          FFDCFilter.processException(
                                                      e,
                                                      "com.ibm.ws.sib.processor.impl.PtoPInputHandler.checkAbleToAcceptMessage",
                                                      "1:3527:1.323",
                                                      this);
  
                          //There are many reasons why this destination lookup might have failed
                          //e.g. destination is not local. Therefore we log this exception and
                          //continue processing.
                          if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                          {
                              SibTr.exception(tc, e);
                          }
                      }
  
                      // If we are not able to put messages to the target or its exception destination then
                      // we want to go on & see if we can put to the link's exception destination. Once more,
                      // the intent is to keep the link open for as long as possible
                      if (blockingReason != DestinationHandler.OUTPUT_HANDLER_FOUND)
                      {
                          int linkBlockingReason = checkLinkAbleToExceptionMessage();
  
                          // If we can exception the message then reset the blockingReason return code
                          if (linkBlockingReason == DestinationHandler.OUTPUT_HANDLER_FOUND)
                              blockingReason = DestinationHandler.OUTPUT_HANDLER_FOUND;
                          // If we didn't get a reason code from checking the target or its exception destination
                          // then use the link's.
                          else if (!checkedTarget)
                              blockingReason = linkBlockingReason;
                      }
  
                      // If the link is blocked we keep track of the target destination because it is
                      // responsible for blocking the link. We'll use this to support the freeing up of the
                      // link at a later stage.
                      if (blockingReason != DestinationHandler.OUTPUT_HANDLER_FOUND)
                      {
                          _linkBlockingDestination = routingDestinationAddr;
                      }
  
                  } // eof else if (! system | temp)
              } // end null routing addr
          } // eof _isLink
  
          if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
              SibTr.exit(tc, "checkAbleToAcceptMessage", Integer.valueOf(blockingReason));
  
          return blockingReason;
      }