docs: public boolean evaluateMessage(
      Selector selectorTree,
      Selector discriminatorTree,
      SIBusMessage msg)
    {
      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
        SibTr.entry(tc, "evaluateMessage", new Object[] { selectorTree, msg });
  
      boolean ret = false;
      Object result = null;
      boolean discriminatorMatches = true; //assume it does match
  
      // Use the dummy evaluation cache, we don't need one hear as we're not
      // searching the MatchSpace
      EvalCache cache = EvalCache.DUMMY;
  
      try
      {
        Evaluator evaluator = Matching.getEvaluator();
        //    See if we need to process a discriminator expression first
        if (discriminatorTree != null)
        {
          discriminatorMatches = false; //can no longer assume it does match
          String discriminator = msg.getDiscriminator();
  
          MatchSpaceKey msk = new DiscriminatorMatchSpaceKey(discriminator);
          // Evaluate message against selector tree
          result = evaluator.eval(discriminatorTree, msk, cache, null, false);
          if (result != null && ((Boolean) result).booleanValue())
          {
            discriminatorMatches = true;
          }
        }
  
        // Evaluate message against selector tree
        if (selectorTree != null && discriminatorMatches)
        {
          result =
            evaluator.eval(selectorTree, (MatchSpaceKey) msg, cache, null, false);
        }
  
      }
      catch (BadMessageFormatMatchingException qex)
      {
        FFDCFilter.processException(
          qex,
          "com.ibm.ws.sib.processor.matching.MessageProcessorMatching.evaluateMessage",
          "1:1824:1.117.1.11",
          this);
  
        SibTr.exception(tc, qex);
  
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(tc, "evaluateMessage", "SICoreException");
  
        SibTr.error(tc, "INTERNAL_MESSAGING_ERROR_CWSIP0002",
          new Object[] {
            "com.ibm.ws.sib.processor.matching.MessageProcessorMatching",
            "1:1834:1.117.1.11",
            qex });
  
        // For now, I'll throw a core exception, but in due course this (or something with a
        // better name) will be externalised in the Core API.
        throw new SIErrorException(
          nls.getFormattedMessage(
            "INTERNAL_MESSAGING_ERROR_CWSIP0002",
            new Object[] {
              "com.ibm.ws.sib.processor.matching.MessageProcessorMatching",
              "1:1844:1.117.1.11",
              qex },
            null),
          qex);
      }
  
      // The result of expression evaluation can be either a
      // boolean, or not, which is interpreted as false.
      if (result instanceof Boolean)
      {
        // This turns a BooleanValue into a boolean
        // it will return false for unknown which is what we want.
        ret = ((Boolean) result).booleanValue();
      }
      else if (result == null)
      {
        ret = false;
      }
      else
      {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(tc, "evaluateMessage", "SICoreException");
        // For now, I'll throw a core exception, but in due course this (or something with a
        // better name) will be externalised in the Core API.
        SibTr.error(tc, "INTERNAL_MESSAGING_ERROR_CWSIP0001",
          new Object[] {
            "com.ibm.ws.sib.processor.matching.MessageProcessorMatching",
            "1:1870:1.117.1.11" });
  
        throw new SIErrorException(
          nls.getFormattedMessage(
            "INTERNAL_MESSAGING_ERROR_CWSIP0001",
            new Object[] {
              "com.ibm.ws.sib.processor.matching.MessageProcessorMatching",
              "1:1877:1.117.1.11" },
            null));
      }
  
      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(tc, "evaluateMessage", Boolean.valueOf(ret));
      return ret;
    }