"accessResultData": {
        "properties": {
          "transformerName": {
            "type": "keyword"
          },
          "encoding": {
            "type": "keyword"
          },
          "data": {
            "type": "binary"
          }
        }
      },
      "contentLength": {
        "type": "long"
      },
      "lastModified": {
        "type": "long"
      },
      "ruleId": {

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

/**
 * The Transformer interface defines methods for transforming response data
 * and retrieving data from access results.
 */
public interface Transformer {

    /**
     * Transforms the given ResponseData into a ResultData.
     *
     * @param responseData the data to be transformed
     * @return the transformed ResultData
     */
    ResultData transform(ResponseData responseData);

     */
    void setInitParameterMap(Map<String, Object> params);

    /**
     * Executes a request and returns the response data.
     *
     * @param data the request data to be executed
     * @return the response data from the executed request
     */
    ResponseData execute(RequestData data);

    /**
     * Closes the crawler client and releases any resources associated with it.

     */
    public void setData(final byte[] data) {
        this.data = data;
    }

    /**
     * Add a child URL.
     * @param url the request data to add to the child URL set
     */
    public void addUrl(final RequestData url) {
        childUrlSet.add(url);
    }

    /**
     * Add child URLs.
     * @param c the collection of request data to add to the child URL set

 * into a ResultData object, and for retrieving the binary data from an AccessResultData object.
 * It extends the AbstractTransformer class.
 *
 * <p>
 * This transformer extracts the binary content from the response body of a web resource,
 * stores it as a byte array in the ResultData, and provides a method to retrieve this data
 * as a ByteArrayInputStream.
 * </p>
 *

    }

    /**
     * Reads the next byte of data from the input stream.
     *
     * @return the next byte of data, or -1 if the end of the stream is reached
     * @throws IOException if an I/O error occurs
     */
    @Override
    public int read() throws IOException {
        return inputStream.read();
    }

    /**
     * Reads up to len bytes of data from the input stream into an array of bytes.
     *

    /**
     * Returns the data associated with the access result.
     *
     * @return the access result data
     */
    AccessResultData<IDTYPE> getAccessResultData();

    /**
     * Sets the data associated with the access result.
     *
     * @param accessResultData the access result data
     */
    void setAccessResultData(AccessResultData<IDTYPE> accessResultData);

    /**
     * Creates a new SitemapsRule instance.
     */
    public SitemapsRule() {
        super();
    }

    /**
     * Matches the given response data against the sitemaps rule.
     * @param responseData The response data.
     * @return true if the response data matches the sitemaps rule, false otherwise.
     */
    @Override
    public boolean match(final ResponseData responseData) {
        if (super.match(responseData)) {

     */
    byte[] getData();

    /**
     * Retrieves the data as a String.
     *
     * @return the data in String format.
     */
    String getDataAsString();

    /**
     * Sets the data for this AccessResultData instance.
     *
     * @param data the byte array containing the data to be set
     */
    void setData(byte[] data);

    /**

 * It stores URL queues, access results, and URL patterns for inclusion and exclusion.
 * This class is designed to be used in a single-threaded environment or with external synchronization.
 *
 * <p>It uses {@code Map} and {@code Queue} data structures to hold the data. The class provides
 * methods to add, remove, clear, and retrieve data from these structures.
 *