final List<Integer> list = new ArrayList<>();
            for (final String value : values) {
                try {
                    list.add(Integer.parseInt(value.trim()));
                } catch (final NumberFormatException e) {}
            }
            this.days = new int[list.size()];
            for (int i = 0; i < list.size(); i++) {
                this.days[i] = list.get(i);

            String line = null;
            while ((line = reader.readLine()) != null) {
                // Remove comments
                final String replacedLine = line.replaceAll("#.*$", StringUtil.EMPTY).trim();

                // Skip empty lines or comment lines
                if (replacedLine.length() == 0) {
                    if (updater != null) {
                        updater.write(line);
                    }

                final Node node = nodeList.get(i);
                buf.append(node.getTextContent()).append(' ');
            }
            return new ExtractData(buf.toString().replaceAll("\\s+", " ").trim());
        } catch (final Exception e) {
            throw new ExtractException(e);
        }
    }

    /**
     * Gets an XPathAPI instance from the cache for the current thread.
     *

            extractContent(rootNode, "", textBuilder, metadataMap, 0);

            final ExtractData extractData = new ExtractData(textBuilder.toString().trim());

            if (extractMetadata) {
                for (final Map.Entry<String, List<String>> entry : metadataMap.entrySet()) {
                    final List<String> values = entry.getValue();

        void shouldProvideMeaningfulDescription() {
            String description = strategy.getDescription();

            assertNotNull(description, "Description should not be null");
            assertFalse(description.trim().isEmpty(), "Description should not be empty");
            assertTrue(
                    description.toLowerCase().contains("compatibility")
                            || description.toLowerCase().contains("fix"),

                if (logger.isDebugEnabled()) {
                    logger.debug("Failed to read data.", e);
                }
                return StringUtil.EMPTY;
            }

            return buf.toString().trim();
        }

        private boolean isSpaceChar(final int c) {
            for (final int spaceChar : spaceChars) {
                if (c == spaceChar) {
                    return true;
                }

     * "user.addresses(myAddress).street"</li>
     * </ul>
     *
     * @param expression not null expression
     * @param root not null object
     * @param trimRootToken trim root token yes/no.
     * @return the object defined by the expression
     * @throws IntrospectionException if any
     */

                    doSetupServerConfig(logger, props, "sslProtocol", v -> sslHostConfig.setSslProtocol(v));
                    doSetupServerConfig(logger, props, "enabledProtocols", v -> sslHostConfig.setEnabledProtocols(v.trim().split(",")));
                    sslHostConfig.addCertificate(certificate);
                    connector.addSslHostConfig(sslHostConfig);

                }
            });

                        + key.getDisplayString() + ".  Existing bindings:\n"
                        + getBoundKeys().stream()
                                .map(Key::toString)
                                .map(String::trim)
                                .sorted()
                                .distinct()
                                .collect(Collectors.joining("\n - ", " - ", "")));
            }
        }

                    || (c >= 0x10000 && c <= 0x10FFFF)) {
                buf.append(c);
            }
        }
        return buf.toString().trim();
    }

    /**
     * Parses the XML content from the provided {@link AccessResultData} and returns a map of the data.
     *
     * @param accessResultData the data containing the XML content to be parsed