docs: @Override
      protected boolean isCompressionAllowed() {
          if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
              Tr.entry(tc, "isCompressionAllowed");
          }
          // check on whether we've already done this step
          if (this.bCheckedAcceptEncoding) {
              if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
                  Tr.exit(tc, "isCompressionAllowed(1): " + this.bCompressionAllowed);
              }
              return this.bCompressionAllowed;
          }
  
          boolean rc = false;
  
          // check target compression first
          byte[] name = null;
          if (isGZipEncoded() || isXGZipEncoded()) {
              // gzip and x-gzip are functionally the same
              name = ContentEncodingValues.GZIP.getByteArray();
          } else if (isZlibEncoded()) {
              name = ContentEncodingValues.DEFLATE.getByteArray();
          } else {
              this.bCheckedAcceptEncoding = true;
              this.bCompressionAllowed = false;
              if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
                  Tr.exit(tc, "isCompressionAllowed(2)", Boolean.FALSE);
              }
              return false;
          }
  
          // comma separated values, < encoding[;q=x] > or < *[;q=x] >
  
          // loop through looking for the matching encoding, then check the qvalue
          // for 0 (not allowed). Keep track if * was found for a final check
          // if the explicit encoding wasn't found.
          int index = 0;
          int x;
          boolean bStarFound = false;
          boolean bStarApproved = false;
          byte[] data = getRequest().getHeader(HttpHeaderKeys.HDR_ACCEPT_ENCODING).asBytes();
          if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
              Tr.debug(tc, "isCompressionAllowed: parsing ["
                           + getRequest().getHeader(HttpHeaderKeys.HDR_ACCEPT_ENCODING).asString()
                           + "] against requested [" + new String(name) + "]");
          }
  
          if (null != data) {
              while (index < data.length) {
                  // search each encoding token (skip leading white space)
                  index = skipWhiteSpace(data, index);
                  if (index >= data.length) {
                      // if the header value was just empty space then only
                      // the identity encoding is acceptable
                      if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                          Tr.debug(tc, "Ran out of data");
                      }
                      break;
                  }
                  // check for the asteric explicitly
                  if ('*' == data[index]) {
                      bStarFound = true;
                      if (++index < data.length && BNFHeaders.SEMICOLON == data[index]) {
                          // now check for the qvalue and set the approved flag
                          ReturnCodes myRC = parseQValue(data, ++index);
                          bStarApproved = myRC.getBooleanValue();
                          index = GenericUtils.skipToChar(data, myRC.getIntValue(), HttpBaseMessage.COMMA) + 1;
                      } else {
                          bStarApproved = true;
                      }
                      continue;
                  }
  
                  // compare the name, check for the x-gzip type values
                  if (index < data.length && ('x' == data[index] || 'X' == data[index])) {
  
                      if (++index < data.length && '-' == data[index]) {
                          if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                              Tr.debug(tc, "skipping past [x-]");
                          }
                          index++;
                      } else {
                          // not x-, go back one for the name comparison
                          index--;
                      }
                  }
                  for (x = 0; x < name.length && index < data.length; x++, index++) {
                      if (name[x] != data[index]) {
                          // try the alternate case for a match
                          if (GenericUtils.reverseCase(name[x]) != data[index]) {
                              // no match found, break out of for loop
                              break;
                          }
                      }
                  }
  
                  // check for the explicit failed match
                  if (x != name.length) {
                      // didn't find a match, skip to the next comma
                      index = GenericUtils.skipToChar(data, index, HttpBaseMessage.COMMA) + 1;
                      continue;
                  }
  
                  // name match so far. If the next char is a comma, then no qvalue
                  // and this compression is allowed. If it is a semi-colon, then
                  // a qvalue is following. Anything else and this wasn't a full
                  // match
                  index = skipWhiteSpace(data, index);
                  if (index < data.length && HttpBaseMessage.COMMA == data[index]) {
                      // this is allowed
                      rc = true;
                  } else if (index < data.length && BNFHeaders.SEMICOLON == data[index]) {
                      // parse the qvalue
                      ReturnCodes myRC = parseQValue(data, ++index);
                      rc = myRC.getBooleanValue();
                  } else if (index >= data.length) {
                      // end of data... means we had a full match
                      rc = true;
                  } else {
                      // partial match... gzip against gzipMe
                      index = GenericUtils.skipToChar(data, index, HttpBaseMessage.COMMA) + 1;
                      continue;
                  }
  
                  break; // out of while loop
              }
          } else {
              // a null (non present) header means that all encodings are accepted
              if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                  Tr.debug(tc, "Accept-Encoding header not present");
              }
              rc = true;
          }
  
          if (!rc && bStarFound && bStarApproved) {
              if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                  Tr.debug(tc, "No explicit match, but wildcard was found");
              }
              rc = true;
          }
  
          this.bCheckedAcceptEncoding = true;
          this.bCompressionAllowed = rc;
  
          if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
              Tr.exit(tc, "isCompressionAllowed(3): " + rc);
          }
          return rc;
      }