docs: private synchronized void pessimisticGet(
      Object key,
      MatchSpaceKey msg,
      EvalCache cache,
      Object rootContext,
      SearchResults result)
      throws MatchingException, BadMessageFormatMatchingException
    {
  
      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
        tc.entry(
          this,cclass,
          "pessimisticGet", new Object[] {key,msg,cache,result});
  
      // Everything must execute under the MatchSpace lock
      // Obtain the cache entry and determine if its otherMatchers and results entries are
      // usable, invalidating them if not.
      CacheEntry e = getCacheEntry(key, true);
      if (e.matchTreeGeneration != matchTreeGeneration)
      {
        e.cachedResults = null;
        e.otherMatchers = null;
      }
      // Look in the cache for a usable cachedResults, using them to satisfy the request
      // iff the results object is willing to accept them.
      if (e.cachedResults != null && result.acceptCacheable(e.cachedResults))
      {
        resultCacheHitGets++;
        pessimisticGets++;
  
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
          tc.exit(this,cclass, "pessimisticGet");
        return;
      }
      // Prepare the EvalCache, since we will be passing the msg through at least some
      // matchers.
      cache.prepareCache(subExpr.evalCacheSize());
      // Next, look in cache for reusable otherMatchers, to avoid searching
      // the full matchTree.
      if (e.otherMatchers != null)
      {
        // Have a cache hit that covers other matchers, so just run them.
        for (int i = 0; i < e.otherMatchers.length; i++)
        {
          try
          {
            e.otherMatchers[i].get(null, msg, cache, rootContext, result);
          }
          catch (RuntimeException exc)
          {
            // No FFDC Code Needed.
            // FFDC driven by wrapper class.
            FFDC.processException(this,
                cclass,
                "com.ibm.ws.sib.matchspace.impl.MatchSpaceImpl.pessimisticGet",
                exc,
                "1:677:1.44");      
  //TODO:          tc.exception(tc, exc);
             
            if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
              tc.exit(this,cclass, "pessimisticGet", exc);
            throw new MatchingException(exc);
          }
        }
        wildCacheHitGets++;
      }
      else
        // Have to do wildcards the slow way
        if (matchTree != null)
        {
          CacheingSearchResults csr = new CacheingSearchResults(result);
          try
          {
            matchTree.get(key, msg, cache, rootContext, csr);
          }
          catch (RuntimeException exc)
          {
            // No FFDC Code Needed.
            // FFDC driven by wrapper class.
            FFDC.processException(this,
                cclass,
                "com.ibm.ws.sib.matchspace.impl.MatchSpaceImpl.pessimisticGet",
                exc,
                "1:704:1.44");               
  //TODO:          tc.exception(tc, exc);
              
            if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
              tc.exit(this,cclass, "pessimisticGet", exc);
            throw new MatchingException(exc);
          }
          e.otherMatchers = csr.getMatchers();
          e.matchTreeGeneration = matchTreeGeneration;
          e.noResultCache |= csr.hasContent;
          wildCacheMissGets++;
        }
      // Now do exact match (if any)
      if (e.exactMatcher != null)
      {
        try
        {
          e.exactMatcher.get(null, msg, cache, rootContext, result);
        }
        catch (RuntimeException exc)
        {
          // No FFDC Code Needed.
          // FFDC driven by wrapper class.
          FFDC.processException(this,
              cclass,
              "com.ibm.ws.sib.matchspace.impl.MatchSpaceImpl.pessimisticGet",
              exc,
              "1:731:1.44");            
  //TODO:        tc.exception(tc, exc);
            
          if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            tc.exit(this,cclass, "pessimisticGet", exc);
          throw new MatchingException(exc);
        }
        exactMatches++;
      }
      // If we are able, place something in the cache for next time
      if (!e.noResultCache)
      {
        e.cachedResults = result.provideCacheable(key);
        if (e.cachedResults != null)
          resultsCached++;
      }
      // And we are done
      pessimisticGets++;
  
      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
        tc.exit(this,cclass, "pessimisticGet");
      return;
    }