Parse the configuration data into the separate values.

@param cc
518000
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");
        }
    }
626667
private void parseConfiguration(String config) {

        CmsSelectConfigurationParser parser = new CmsSelectConfigurationParser(config);
        // set the help info first!!
        for (Entry<String, String> helpEntry : parser.getHelpTexts().entrySet()) {
            m_selectBox.setTitle(helpEntry.getKey(), helpEntry.getValue());
        }
        //set value and option to the combo box.
        m_selectBox.setItems(parser.getOptions());
        //if one entrance is declared for default.
        if (parser.getDefaultValue() != null) {
            //set the declared value selected.
            m_selectBox.selectValue(parser.getDefaultValue());
            m_defaultValue = parser.getDefaultValue();
        }
        fireChangeEvent();
    }
1110619
public void parse(byte[] data) throws ParseException {
        Text text = new Text();
        text.strain(data, 0, data.length);
        init(text);
    }
764719
function parse_cc_xml(data, opts) {
	var d = [];
	if(!data) return d;
	var l = 0, i = 1;
	(data.match(tagregex)||[]).forEach(function(x) {
		var y = parsexmltag(x);
		switch(y[0]) {
			case '<?xml': break;
			/* 18.6.2  calcChain CT_CalcChain 1 */
			case '<calcChain': case '<calcChain>': case '</calcChain>': break;
			/* 18.6.1  c CT_CalcCell 1 */
			case '<c': delete y[0]; if(y.i) i = y.i; else y.i = i; d.push(y); break;
		}
	});
	return d;
}
1215473
public void parse() {
        ChunkHeader firstChunkHeader = readChunkHeader();
        if (firstChunkHeader == null) {
            return;
        }

        switch (firstChunkHeader.getChunkType()) {
            case ChunkType.XML:
            case ChunkType.NULL:
                break;
            case ChunkType.STRING_POOL:
            default:
                // strange chunk header type, just skip this chunk header?
        }

        // read string pool chunk
        ChunkHeader stringPoolChunkHeader = readChunkHeader();
        if (stringPoolChunkHeader == null) {
            return;
        }

        ParseUtils.checkChunkType(ChunkType.STRING_POOL, stringPoolChunkHeader.getChunkType());
        stringPool = ParseUtils.readStringPool(buffer, (StringPoolHeader) stringPoolChunkHeader);

        // read on chunk, check if it was an optional XMLResourceMap chunk
        ChunkHeader chunkHeader = readChunkHeader();
        if (chunkHeader == null) {
            return;
        }

        if (chunkHeader.getChunkType() == ChunkType.XML_RESOURCE_MAP) {
            long[] resourceIds = readXmlResourceMap((XmlResourceMapHeader) chunkHeader);
            resourceMap = new String[resourceIds.length];
            for (int i = 0; i < resourceIds.length; i++) {
                resourceMap[i] = Attribute.AttrIds.getString(resourceIds[i]);
            }
            chunkHeader = readChunkHeader();
        }

        while (chunkHeader != null) {
                /*if (chunkHeader.chunkType == ChunkType.XML_END_NAMESPACE) {
                    break;
                }*/
            long beginPos = buffer.position();
            switch (chunkHeader.getChunkType()) {
                case ChunkType.XML_END_NAMESPACE:
                    XmlNamespaceEndTag xmlNamespaceEndTag = readXmlNamespaceEndTag();
                    xmlStreamer.onNamespaceEnd(xmlNamespaceEndTag);
                    break;
                case ChunkType.XML_START_NAMESPACE:
                    XmlNamespaceStartTag namespaceStartTag = readXmlNamespaceStartTag();
                    xmlStreamer.onNamespaceStart(namespaceStartTag);
                    break;
                case ChunkType.XML_START_ELEMENT:
                    XmlNodeStartTag xmlNodeStartTag = readXmlNodeStartTag();
                    break;
                case ChunkType.XML_END_ELEMENT:
                    XmlNodeEndTag xmlNodeEndTag = readXmlNodeEndTag();
                    break;
                case ChunkType.XML_CDATA:
                    XmlCData xmlCData = readXmlCData();
                    break;
                default:
                    if (chunkHeader.getChunkType() >= ChunkType.XML_FIRST_CHUNK &&
                            chunkHeader.getChunkType() <= ChunkType.XML_LAST_CHUNK) {
                        Buffers.skip(buffer, chunkHeader.getBodySize());
                    } else {
                        throw new ParserException("Unexpected chunk type:" + chunkHeader.getChunkType());
                    }
            }
            Buffers.position(buffer, beginPos + chunkHeader.getBodySize());
            chunkHeader = readChunkHeader();
        }
    }
783918
@SuppressWarnings("unchecked")
    public List<CertificateMeta> parse() throws CertificateException {
        CMSSignedData cmsSignedData;
        try {
            cmsSignedData = new CMSSignedData(data);
        } catch (CMSException e) {
            throw new CertificateException(e);
        }
        Store<X509CertificateHolder> certStore = cmsSignedData.getCertificates();
        SignerInformationStore signerInfos = cmsSignedData.getSignerInfos();
        Collection<SignerInformation> signers = signerInfos.getSigners();
        List<X509Certificate> certificates = new ArrayList<>();
        for (SignerInformation signer : signers) {
            Collection<X509CertificateHolder> matches = certStore.getMatches(signer.getSID());
            for (X509CertificateHolder holder : matches) {
                certificates.add(new JcaX509CertificateConverter().setProvider(provider).getCertificate(holder));
            }
        }
        return CertificateMetas.from(certificates);
    }
162623
private void parseExternalsConfig(final Node node,
			final ConfigSettings config)
	{

		String name, value;
		Node nnode;
		NodeList list = node.getChildNodes();

		int length = list.getLength();
		for (int i = 0; i < length; i++) {
			nnode = list.item(i);

			name = nnode.getNodeName().toUpperCase();
			if (name.equals(KEY_SEVENZIP)) {

				value = nnode.getChildNodes().item(0).getNodeValue();
				value = value.substring(1, value.length() - 1);

				config.setConfigParameter(ConfigurationKeys.PATH_PROGRAM_7ZIP,
						value);

			}
		}
	}
1230725
public void setCc(Object cc) throws ApplicationException {
	if (StringUtil.isEmpty(cc)) return;
	try {
	    smtp.addCC(cc);
	}
	catch (Exception e) {
	    throw new ApplicationException("attribute [cc] of the tag [mail] is invalid", e.getMessage());
	}
    }
169566
private void parseConfig(String config) {

        if (isValidConfig(config)) {
            String[] conf = config.split("x");
            if (conf[0].trim().equals("?")) {
                m_width = I_CmsFormatRestriction.DIMENSION_NOT_SET;
            } else {
                m_width = CmsClientStringUtil.parseInt(conf[0]);
                m_width = (m_width == 0) ? I_CmsFormatRestriction.DIMENSION_NOT_SET : m_width;
            }
            if (conf[1].trim().equals("?")) {
                m_height = I_CmsFormatRestriction.DIMENSION_NOT_SET;
            } else {
                m_height = CmsClientStringUtil.parseInt(conf[1]);
                m_height = (m_height == 0) ? I_CmsFormatRestriction.DIMENSION_NOT_SET : m_height;
            }
        }
    }
1337720
public void parseConstantPool()
    throws IOException
  {
    int count = readShort();

    for (int i = 1; i < count; i++) {
      ConstantPoolEntry entry = parseConstantPoolEntry(i);

      _cp.addConstant(entry);
      
      if (entry instanceof DoubleConstant ||
          entry instanceof LongConstant) {
        i++;
        _cp.addConstant(null);
      }
    }
  }
482746
private CodePluginConfig parsePluginConfig(InputStream inputStream) {
        Gson gson = new Gson();
        CodePluginConfig config = gson.fromJson(new InputStreamReader(inputStream), CodePluginConfig.class);
        logger.log(Level.INFO, "Loaded configuration " + config);
        return config;
    }
1061750
@Override
  protected void initParser() throws MtasConfigException {
    super.initParser();
    if (config != null) {
      for (int i = 0; i < config.children.size(); i++) {
        MtasConfiguration current = config.children.get(i);
        if (current.name.equals(PENNTREEBANK_IGNORE)) {
          for (int j = 0; j < current.children.size(); j++) {
            if (current.children.get(j).name.equals(PENNTREEBANK_NODE)) {
              String nameVariable = current.children.get(j).attributes
                  .get(PENNTREEBANK_NODE_NAME);
              if (!nameVariable.isEmpty()) {
                ignoreNodes.add(nameVariable);
              }
            }
          }
        }
      }
    }
  }
795649
@Override
    public void update(ChannelData cc) {
        synchronized (this) {
            // can't do two updates at the same time
            if (this.config.checkAndSetValues(cc)) {
                this.alists = AccessLists.getInstance(this.config);
            }
        }
    }
51625
@Override
	public void read(final DataInput in) throws IOException {

		synchronized (this.confData) {

			final int numberOfProperties = in.readInt();

			for (int i = 0; i < numberOfProperties; i++) {
				final String key = StringRecord.readString(in);
				final String value = StringRecord.readString(in);
				this.confData.put(key, value);
			}
		}
	}
614923
public static void parseCommonLoaderAttributes(XMLExtendedStreamReader reader, int i,
                                                  StoreConfigurationBuilder<?, ?> builder) throws XMLStreamException {
      throw ParseUtils.unexpectedAttribute(reader, i);
   }
753436
public <CC extends CellConsumer> CC parseAll(CC cellConsumer)
			throws IOException {
		_parseAll(wrapConsumer(cellConsumer), false);

		return cellConsumer;
	}
1213836
@Override
  public void parse(String contents) throws SourceMapParseException {
    SourceMapObject sourceMapObject = SourceMapObjectParser.parse(contents);
    parse(sourceMapObject, null);
  }