docs: private void parseConfig(ChannelData cc) {
  
          if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
              Tr.entry(tc, "parseConfig: " + cc.getName());
          }
  
          Map<Object, Object> propsIn = cc.getPropertyBag();
  
          Map<Object, Object> props = new HashMap<Object, Object>();
          // convert all keys to valid case independent of case
          String key;
          Object value;
  
          // match keys independent of case.
          // So this is a bit ugly, but the parsing code is not state independent, meaning if it parses A then and
          // only then it will parse B, and we can't be certain that only properties that we know about from the HTTP Config
          // are in this Map (so we can't just lower case everything).  So, to be case independent we need to convert
          // the entries to their known internal string constants.  We shouldn't need to configure the channel often, and there
          // should not be many custom properties, so performance should not be an issue.
          for (Entry<Object, Object> entry : propsIn.entrySet()) {
              key = (String) entry.getKey();
              value = entry.getValue();
  
              // First comparisons are for ones exposed in metatype.xml
              if (key.equalsIgnoreCase(HttpConfigConstants.PROPNAME_KEEPALIVE_ENABLED)) {
                  props.put(HttpConfigConstants.PROPNAME_KEEPALIVE_ENABLED, value);
                  continue;
              }
              if (key.equalsIgnoreCase(HttpConfigConstants.PROPNAME_MAX_PERSIST)) {
                  props.put(HttpConfigConstants.PROPNAME_MAX_PERSIST, value);
                  continue;
              }
              if (key.equalsIgnoreCase(HttpConfigConstants.PROPNAME_PERSIST_TIMEOUT)) {
                  props.put(HttpConfigConstants.PROPNAME_PERSIST_TIMEOUT, value);
                  continue;
              }
              if (key.equalsIgnoreCase(HttpConfigConstants.PROPNAME_READ_TIMEOUT)) {
                  props.put(HttpConfigConstants.PROPNAME_READ_TIMEOUT, value);
                  continue;
              }
              if (key.equalsIgnoreCase(HttpConfigConstants.PROPNAME_WRITE_TIMEOUT)) {
                  props.put(HttpConfigConstants.PROPNAME_WRITE_TIMEOUT, value);
                  continue;
              }
              if (key.equalsIgnoreCase(HttpConfigConstants.PROPNAME_JIT_ONLY_READS)) {
                  props.put(HttpConfigConstants.PROPNAME_JIT_ONLY_READS, value);
                  continue;
              }
              if (key.equalsIgnoreCase(HttpConfigConstants.PROPNAME_OUTGOING_VERSION)) {
                  props.put(HttpConfigConstants.PROPNAME_OUTGOING_VERSION, value);
                  continue;
              }
              if (key.equalsIgnoreCase(HttpConfigConstants.PROPNAME_DIRECT_BUFF)) {
                  props.put(HttpConfigConstants.PROPNAME_DIRECT_BUFF, value);
                  continue;
              }
              if (key.equalsIgnoreCase(HttpConfigConstants.PROPNAME_OUTGOING_HDR_BUFFSIZE)) {
                  props.put(HttpConfigConstants.PROPNAME_OUTGOING_HDR_BUFFSIZE, value);
                  continue;
              }
              if (key.equalsIgnoreCase(HttpConfigConstants.PROPNAME_INCOMING_HDR_BUFFSIZE)) {
                  props.put(HttpConfigConstants.PROPNAME_INCOMING_HDR_BUFFSIZE, value);
                  continue;
              }
              if (key.equalsIgnoreCase(HttpConfigConstants.PROPNAME_INCOMING_BODY_BUFFSIZE)) {
                  props.put(HttpConfigConstants.PROPNAME_INCOMING_BODY_BUFFSIZE, value);
                  continue;
              }
              if (key.equalsIgnoreCase(HttpConfigConstants.PROPNAME_BYTE_CACHE_SIZE)) {
                  props.put(HttpConfigConstants.PROPNAME_BYTE_CACHE_SIZE, value);
                  continue;
              }
              if (key.equalsIgnoreCase(HttpConfigConstants.PROPNAME_EXTRACT_VALUE)) {
                  props.put(HttpConfigConstants.PROPNAME_EXTRACT_VALUE, value);
                  continue;
              }
              if (key.equalsIgnoreCase(HttpConfigConstants.PROPNAME_BINARY_TRANSPORT)) {
                  props.put(HttpConfigConstants.PROPNAME_BINARY_TRANSPORT, value);
                  continue;
              }
              if (key.equalsIgnoreCase(HttpConfigConstants.PROPNAME_LIMIT_FIELDSIZE)) {
                  props.put(HttpConfigConstants.PROPNAME_LIMIT_FIELDSIZE, value);
                  continue;
              }
              if (key.equalsIgnoreCase(HttpConfigConstants.PROPNAME_LIMIT_NUMHEADERS)) {
                  props.put(HttpConfigConstants.PROPNAME_LIMIT_NUMHEADERS, value);
                  continue;
              }
              if (key.equalsIgnoreCase(HttpConfigConstants.PROPNAME_LIMIT_NUMBER_RESPONSES)) {
                  props.put(HttpConfigConstants.PROPNAME_LIMIT_NUMBER_RESPONSES, value);
                  continue;
              }
              if (key.equalsIgnoreCase(HttpConfigConstants.PROPNAME_MSG_SIZE_LIMIT)) {
                  props.put(HttpConfigConstants.PROPNAME_MSG_SIZE_LIMIT, value);
                  continue;
              }
              if (key.equalsIgnoreCase(HttpConfigConstants.PROPNAME_ALLOW_RETRIES)) {
                  props.put(HttpConfigConstants.PROPNAME_ALLOW_RETRIES, value);
                  continue;
              }
              if (key.equalsIgnoreCase(HttpConfigConstants.PROPNAME_HEADER_VALIDATION)) {
                  props.put(HttpConfigConstants.PROPNAME_HEADER_VALIDATION, value);
                  continue;
              }
              if (key.equalsIgnoreCase(HttpConfigConstants.PROPNAME_STRICT_URL_FORMAT)) {
                  props.put(HttpConfigConstants.PROPNAME_STRICT_URL_FORMAT, value);
                  continue;
              }
              if (key.equalsIgnoreCase(HttpConfigConstants.PROPNAME_SERVER_HEADER_VALUE)) {
                  props.put(HttpConfigConstants.PROPNAME_SERVER_HEADER_VALUE, value);
                  continue;
              }
              if (key.equalsIgnoreCase(HttpConfigConstants.PROPNAME_REMOVE_SERVER_HEADER)) {
                  props.put(HttpConfigConstants.PROPNAME_REMOVE_SERVER_HEADER, value);
                  continue;
              }
              if (key.equalsIgnoreCase(HttpConfigConstants.PROPNAME_DATE_HEADER_RANGE)) {
                  props.put(HttpConfigConstants.PROPNAME_DATE_HEADER_RANGE, value);
                  continue;
              }
              if (key.equalsIgnoreCase(HttpConfigConstants.PROPNAME_COOKIES_CONFIGURE_NOCACHE)) {
                  props.put(HttpConfigConstants.PROPNAME_COOKIES_CONFIGURE_NOCACHE, value);
                  continue;
              }
              if (key.equalsIgnoreCase(HttpConfigConstants.PROPNAME_HEADER_CHANGE_LIMIT)) {
                  props.put(HttpConfigConstants.PROPNAME_HEADER_CHANGE_LIMIT, value);
                  continue;
              }
              if (key.equalsIgnoreCase(HttpConfigConstants.PROPNAME_AUTODECOMPRESSION)) {
                  props.put(HttpConfigConstants.PROPNAME_AUTODECOMPRESSION, value);
                  continue;
              }
              if (key.equalsIgnoreCase(HttpConfigConstants.PROPNAME_ENABLE_SMUGGLING_PROTECTION)) {
                  props.put(HttpConfigConstants.PROPNAME_ENABLE_SMUGGLING_PROTECTION, value);
                  continue;
              }
              if (key.equalsIgnoreCase(HttpConfigConstants.PROPNAME_RUNNING_ON_ZOS)) {
                  props.put(HttpConfigConstants.PROPNAME_RUNNING_ON_ZOS, value);
                  continue;
              }
              if (key.equalsIgnoreCase(HttpConfigConstants.PROPNAME_SERVANT_REGION)) {
                  props.put(HttpConfigConstants.PROPNAME_SERVANT_REGION, value);
                  continue;
              }
              if (key.equalsIgnoreCase(HttpConfigConstants.PROPNAME_CONTROL_REGION)) {
                  props.put(HttpConfigConstants.PROPNAME_CONTROL_REGION, value);
                  continue;
              }
              if (key.equalsIgnoreCase(HttpConfigConstants.PROPNAME_V0_COOKIE_RFC1123_COMPAT)) {
                  props.put(HttpConfigConstants.PROPNAME_V0_COOKIE_RFC1123_COMPAT, value);
                  continue;
              }
              if (key.equalsIgnoreCase(HttpConfigConstants.PROPNAME_DO_NOT_ALLOW_DUPLICATE_SET_COOKIES)) {
                  props.put(HttpConfigConstants.PROPNAME_DO_NOT_ALLOW_DUPLICATE_SET_COOKIES, value);
                  continue;
              }
              if (key.equalsIgnoreCase(HttpConfigConstants.PROPNAME_WAIT_FOR_END_OF_MESSAGE)) {
                  props.put(HttpConfigConstants.PROPNAME_WAIT_FOR_END_OF_MESSAGE, value);
                  continue;
              }
              if (key.equalsIgnoreCase(HttpConfigConstants.REMOVE_CLHEADER_IN_TEMP_STATUS_RFC7230_COMPAT)) {
                  props.put(HttpConfigConstants.REMOVE_CLHEADER_IN_TEMP_STATUS_RFC7230_COMPAT, value);
                  continue;
              }
              if (key.equalsIgnoreCase(HttpConfigConstants.PROPNAME_PREVENT_RESPONSE_SPLIT)) {
                  props.put(HttpConfigConstants.PROPNAME_PREVENT_RESPONSE_SPLIT, value);
                  continue;
              }
              if (key.equalsIgnoreCase(HttpConfigConstants.PROPNAME_PURGE_DATA_DURING_CLOSE)) {
                  props.put(HttpConfigConstants.PROPNAME_PURGE_DATA_DURING_CLOSE, value);
                  continue;
              }
              if (key.equalsIgnoreCase(HttpConfigConstants.PROPNAME_THROW_IOE_FOR_INBOUND_CONNECTIONS)) {
                  props.put(HttpConfigConstants.PROPNAME_THROW_IOE_FOR_INBOUND_CONNECTIONS, value);
                  continue;
              }
              if (key.equalsIgnoreCase(HttpConfigConstants.PROPNAME_SKIP_PATH_QUOTE)) {
                  props.put(HttpConfigConstants.PROPNAME_SKIP_PATH_QUOTE, value);
                  continue;
              }
              if (key.equalsIgnoreCase(HttpConfigConstants.PROPNAME_H2_CONN_CLOSE_TIMEOUT)) {
                  props.put(HttpConfigConstants.PROPNAME_H2_CONN_CLOSE_TIMEOUT, value);
                  continue;
              }
              if (key.equalsIgnoreCase(HttpConfigConstants.PROPNAME_H2_CONN_READ_WINDOW_SIZE)) {
                  props.put(HttpConfigConstants.PROPNAME_H2_CONN_READ_WINDOW_SIZE, value);
                  continue;
              }
              if (key.equalsIgnoreCase(HttpConfigConstants.PROPNAME_PURGE_REMAINING_RESPONSE)) {
                  props.put(HttpConfigConstants.PROPNAME_PURGE_REMAINING_RESPONSE, value);
                  continue;
              }
  
              if (key.equalsIgnoreCase(HttpConfigConstants.PROPNAME_PROTOCOL_VERSION)) {
                  props.put(HttpConfigConstants.PROPNAME_PROTOCOL_VERSION, value);
                  continue;
              }
  
              if (key.equalsIgnoreCase(HttpConfigConstants.PROPNAME_H2_CONNECTION_IDLE_TIMEOUT)) {
                  props.put(HttpConfigConstants.PROPNAME_H2_CONNECTION_IDLE_TIMEOUT, value);
                  continue;
              }
  
              if (key.equalsIgnoreCase(HttpConfigConstants.PROPNAME_H2_MAX_CONCURRENT_STREAMS)) {
                  props.put(HttpConfigConstants.PROPNAME_H2_MAX_CONCURRENT_STREAMS, value);
              }
  
              if (key.equalsIgnoreCase(HttpConfigConstants.PROPNAME_H2_MAX_FRAME_SIZE)) {
                  props.put(HttpConfigConstants.PROPNAME_H2_MAX_FRAME_SIZE, value);
              }
  
              if (key.equalsIgnoreCase(HttpConfigConstants.PROPNAME_REMOTE_PROXIES)) {
                  props.put(HttpConfigConstants.PROPNAME_REMOTE_PROXIES, value);
              }
  
              if (key.equalsIgnoreCase(HttpConfigConstants.PROPNAME_REMOTE_IP)) {
                  props.put(HttpConfigConstants.PROPNAME_REMOTE_IP, value);
              }
  
              if (key.equalsIgnoreCase(HttpConfigConstants.PROPNAME_REMOTE_IP_ACCESS_LOG)) {
                  props.put(HttpConfigConstants.PROPNAME_REMOTE_IP_ACCESS_LOG, value);
              }
  
              props.put(key, value);
          }
  
          parseProtocolVersion(props);
          parsePersistence(props);
          parseOutgoingVersion(props);
          parseBufferType(props);
          parseOutgoingBufferSize(props);
          parseIncomingHdrBufferSize(props);
          parseIncomingBodyBufferSize(props);
          parsePersistTimeout(props);
          parseReadTimeout(props);
          parseWriteTimeout(props);
          parseByteCacheSize(props);
          parseDelayedExtract(props);
          parseBinaryTransport(props);
          parseLimitFieldSize(props);
          parseLimitNumberHeaders(props);
          parseLimitNumberResponses(props);
          parseLimitMessageSize(props);
          parseAllowRetries(props);
          parseLoggingInfo(props);
          parseHeaderValidation(props);
          parseStrictURLFormat(props);
          parseServerHeader(props);
          parseDateHeaderRange(props);
          parseCookieUpdate(props);//PI75280
          parseHeaderChangeLimit(props);
          parseAutoDecompression(props);
          parseRequestSmugglingProtection(props);
          parsev0CookieDateRFC1123compat(props);
          parseDoNotAllowDuplicateSetCookies(props); //PI31734
          parseWaitForEndOfMessage(props); //PI33453
          parseRemoveCLHeaderInTempStatusRespRFC7230compat(props);//PI35277
          parsePreventResponseSplit(props); //PI45266
          parseAttemptPurgeData(props); //PI11176
          parseThrowIOEForInboundConnections(props); //PI57542
          parseSkipCookiePathQuotes(props); //738893
          parseH2ConnCloseTimeout(props);
          parseH2ConnReadWindowSize(props);
          parsePurgeRemainingResponseBody(props); //PI81572
          parseH2ConnectionIdleTimeout(props);
          parseH2MaxConcurrentStreams(props);
          parseH2MaxFrameSize(props);
          parseRemoteIp(props);
          parseRemoteIpProxies(props);
          parseRemoteIpAccessLog(props);
  
          if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
              Tr.exit(tc, "parseConfig");
          }
      }