import org.codelibs.fess.crawler.entity.ResponseData;

/**
 * RegexRule is a rule implementation that uses regular expressions to match against the ResponseData.
 * It allows defining multiple regular expressions for different fields of the ResponseData.
 * The rule can be configured to require all regular expressions to match (allRequired = true) or
 * only one of them (allRequired = false). It also supports a default rule that always matches.
 *

        boostExpression = expression;
    }

    /**
     * Gets the current match expression.
     *
     * @return the match expression string
     */
    public String getMatchExpression() {
        return matchExpression;
    }

    /**
     * Sets the match expression used to determine if documents should be boosted.
     *
     * @param expression the match expression string
     */

### Modern Java 21 Support
- **Pattern Matching** - Leverages modern Java pattern matching for efficient type checking and conversion
- **Switch Expressions** - Optimized implementations using switch expressions for better performance
- **Sequenced Collections** - Full support for Java 21 sequenced collections API with dedicated utility methods

     *  @param expression A valid XPath string.
     *  @return A XPathNodes, should never be null.
     *
     * @throws XPathExpressionException if an XPath expression error occurs.
     */
    public XPathNodes selectNodeList(final Node contextNode, final String expression) throws XPathExpressionException {
        return xPath.evaluateExpression(expression, contextNode, XPathNodes.class);
    }

    /**

Traditional retrieval of objects is always as whole entities, i.e GetObject for a 5 GiB object, will always return 5 GiB of data. S3 Select API allows us to retrieve a subset of data by using simple SQL expressions. By using Select API to retrieve only the data needed by the application, drastic performance improvements can be achieved.

You can use the Select API to query objects with following features:

            clientFactoryList.remove(0);
        }
    }

    /**
     * Registers a client component with a regular expression.
     * The component will be loaded into all registered CrawlerClientFactories.
     * @param regex The regular expression to match URLs.
     * @param componentName The name of the component to register.
     */

## Add regular expressions { #add-regular-expressions }

You can define a <abbr title="A regular expression, regex or regexp is a sequence of characters that define a search pattern for strings.">regular expression</abbr> `pattern` that the parameter should match:

{* ../../docs_src/query_params_str_validations/tutorial004_an_py310.py hl[11] *}

This specific regular expression pattern checks that the received parameter value:

        violations = validator.validate(bean);
        assertTrue(violations.isEmpty());
    }

    // Test validation with invalid cron expressions
    public void test_invalidCronExpressions() {
        TestBean bean = new TestBean();

        // Test invalid cron expression
        bean.setCronExpression("invalid");
        Set<ConstraintViolation<TestBean>> violations = validator.validate(bean);

 *
 * <p>The extractor supports two types of password management:
 * <ul>
 *   <li>Static passwords configured via {@link #addPassword(String, String)}</li>
 *   <li>Dynamic passwords provided through extraction parameters</li>
 * </ul>
 *
 * <p>Passwords are matched against URLs or resource names using regular expression patterns.

import org.w3c.dom.Document;
import org.w3c.dom.Node;
import org.xml.sax.InputSource;

/**
 * {@link XpathTransformer} is a class that transforms HTML content into XML format based on XPath expressions.
 * It extracts data from an HTML document by applying XPath rules defined in {@link #fieldRuleMap}.
 * The extracted data is then formatted into an XML structure and stored in the {@link ResultData}.
 * <p>