*/
public interface AccessResultCallback<RESULT extends AccessResult<?>> {
    /**
     * Processes the given access result.
     *
     * @param accessResult the result of the access operation to be processed
     */
    /**
     * Processes the given access result.
     *
     * @param accessResult the result of the access operation to be processed
     */
    void iterate(RESULT accessResult);

A "middleware" is a function that works with every **request** before it is processed by any specific *path operation*. And also with every **response** before returning it.

* It takes each **request** that comes to your application.
* It can then do something to that **request** or run any needed code.
* Then it passes the **request** to be processed by the rest of the application (by some *path operation*).

    /**
     * Current status of the crawler.
     */
    protected volatile CrawlerStatus status = CrawlerStatus.INITIALIZING;

    /**
     * Filter for URLs to control which URLs are processed.
     */
    protected UrlFilter urlFilter;

    /**
     * Manager for crawling rules and configurations.
     */
    protected RuleManager ruleManager;

    /**

     */
    public SitemapsResponseProcessor() {
        super();
    }

    /**
     * Processes the given response data, extracting URLs from sitemaps.
     * @param responseData The response data.
     */
    @Override
    public void process(final ResponseData responseData) {
        final SitemapsHelper sitemapsHelper = crawlerContainer.getComponent("sitemapsHelper");

```

### Monitoring

```java
// Monitor crawling progress
while (crawler.crawlerContext.getStatus() == CrawlerStatus.RUNNING) {
    int processed = dataService.getCount(sessionId);
    System.out.println("Processed: " + processed + " URLs");
    Thread.sleep(5000);
}
```

## Contributing

We welcome contributions to Fess Crawler! Please follow these guidelines:

In particular, this may be a good alternative to logic in a middleware.

For example, if you want to read or manipulate the request body before it is processed by your application.

/// danger

This is an "advanced" feature.

If you are just starting with **FastAPI** you might want to skip this section.

///

## Use cases { #use-cases }

        this.extractorMap = extractorMap;
    }

    /**
     * Creates a new ExtractorBuilder instance.
     *
     * @param in      The input stream to be processed by the extractor.
     * @param params  The parameters to be used by the extractor.
     * @return A new ExtractorBuilder instance.
     */

     * - Any character between 0x20 and 0xD7FF
     * - Any character between 0xE000 and 0xFFFD
     * - Any character between 0x10000 and 0x10FFFF
     *
     * @param in the input string to be processed
     * @return a new string with invalid XML characters removed, or the original
     *         string if it is empty
     */
    public static String stripInvalidXMLCharacters(final String in) {

ecommerce application might include personally identifiable information (PII). When the same data is processed for analytics, PII should be redacted. However, if the same dataset is used for a marketing campaign, you might need to enrich the data with additional details, such as information from the customer loyalty database.

MinIO's Object Lambda, enables application developers to process data retrieved from MinIO before returning it to an application. You can register a Lambda Function target...

         * - The maximum size of alphanumeric and symbol terms can be limited by `maxAlphanumTermSize` and `maxSymbolTermSize` respectively.
         *
         * @return A processed string with terms and spaces, or an empty string if the reader is null or an IOException occurs.
         */
        public String execute() {
            if (reader == null) {
                return StringUtil.EMPTY;