import jakarta.annotation.Resource;

/**
 * A response processor implementation that handles sitemaps.
 * It parses the response body as a SitemapSet, extracts URLs from the sitemaps,
 * and adds them as child URLs to be crawled.
 *
 * <p>
 * This class uses a {@link SitemapsHelper} to parse the sitemap XML or text.
 * It then iterates through the sitemaps in the SitemapSet, extracts the URL

 *
 * <p>This factory is typically initialized through dependency injection and can be
 * configured with initialization parameters that are passed to all registered clients.</p>
 *
 * <p>Features:</p>
 * <ul>
 *   <li>Pattern-based client mapping</li>
 *   <li>Ordered client registration</li>
 *   <li>Bulk client registration</li>
 *   <li>Automatic client initialization</li>
 *   <li>Resource cleanup management</li>
 * </ul>
 *
 */

     * @param parser the SAX parser to configure
     * @throws SAXNotRecognizedException if the parser doesn't recognize the feature
     * @throws SAXNotSupportedException if the parser doesn't support the feature
     */
    protected void disableExternalResources(final SAXParser parser) throws SAXNotRecognizedException, SAXNotSupportedException {
        try {

            spfactory.setFeature(Constants.FEATURE_EXTERNAL_PARAMETER_ENTITIES, false);
            // create a sax parser
            final SAXParser parser = spfactory.newSAXParser();
            try {
                parser.setProperty(XMLConstants.ACCESS_EXTERNAL_DTD, StringUtil.EMPTY);
                parser.setProperty(XMLConstants.ACCESS_EXTERNAL_SCHEMA, StringUtil.EMPTY);
            } catch (final Exception e) {

        // Default constructor
    }

    /**
     * Parses a robots.txt file from the given input stream using UTF-8 encoding.
     * @param stream the input stream to parse
     * @return the parsed RobotsTxt object, or null if disabled
     */
    public RobotsTxt parse(final InputStream stream) {
        return parse(stream, Constants.UTF_8);
    }

    /**

    @Resource
    protected CrawlerContainer crawlerContainer;

    /** Map of parser features to configure the DOM parser. */
    protected Map<String, String> featureMap = new HashMap<>();

    /** Map of parser properties to configure the DOM parser. */
    protected Map<String, String> propertyMap = new HashMap<>();

    }

    /**
     * Creates a parse context.
     *
     * @param parser A parser.
     * @param params A map of parameters.
     * @return a parse context.
     */
    protected ParseContext createParseContext(final Parser parser, final Map<String, String> params) {
        final ParseContext parseContext = new ParseContext();
        parseContext.set(Parser.class, parser);

        try {
            final StandardQueryParser parser = new StandardQueryParser();
            parser.setDefaultOperator(StandardQueryConfigHandler.Operator.AND);

            // Parse with the first field if available, otherwise use "default"
            String defaultField = fields != null && fields.length > 0 ? fields[0] : "default";
            termQueryList = getTermQueryList(parser.parse(q, defaultField), fields);

     * @return a list of suggest items parsed from the query log
     */
    List<SuggestItem> parseQueryLog(QueryLog queryLog, String[] fields, String[] tagFieldNames, String roleFieldName,
            ReadingConverter readingConverter, Normalizer normalizer);

    /**
     * Parses a document and extracts suggest items based on the provided fields and converters.
     *

        final DOMParser parser = getDomParser();
        try (final Reader reader = new StringReader(content)) {
            parser.parse(new InputSource(reader));
        } catch (final Exception e) {
            logger.warn("Failed to parse the content.", e);
            return new ExtractData(extractString(content));
        }

        final Document document = parser.getDocument();
        try {