} catch (final Throwable t) {
            logger.warn("Failed to set SessionTrackingMode.", t);
        }

        split(fessConfig.getQueryFacetQueries(), "\n").of(stream -> stream.map(String::trim).filter(StringUtil::isNotEmpty).forEach(s -> {
            final String[] values = StringUtils.split(s, ":", 2);
            if (values.length != 2) {
                return;
            }

              // We can't check that the key is mightContain() == false before the
              // put() because the key could have already been generated *or* the
              // bloom filter might say true even when it's not there (false
              // positive).
              bloomFilter.put(key);
              // False negative should *never* happen.

            }
            if (getLogger().isDebugEnabled()) {
                getLogger().debug("ExtractData: {}", extractData);
            }
            // meta
            extractData.getKeySet().stream().filter(k -> extractData.getValues(k) != null).forEach(key -> {
                final String[] values = extractData.getValues(key);
                metaDataMap.put(key, values);

                // meta -> content

              // We can't check that the key is mightContain() == false before the
              // put() because the key could have already been generated *or* the
              // bloom filter might say true even when it's not there (false
              // positive).
              bloomFilter.put(key);
              // False negative should *never* happen.

    /**
     * Any open of this file cannot be exclusive
     */
    public static final int FILE_DISALLOW_EXCLUSIVE = 0x20000;
    /**
     * Reserve an opportunistic lock filter on the open
     */
    public static final int FILE_RESERVE_OPFILTER = 0x100000;
    /**
     * Open a reparse point and bypass normal reparse point processing
     */

	ResumeItemsSkipped uint64 `json:"-"`
	ResumeBytesDone    uint64 `json:"-"`
	ResumeBytesFailed  uint64 `json:"-"`
	ResumeBytesSkipped uint64 `json:"-"`

	// Filled on startup/restarts.
	QueuedBuckets []string

	// Filled during heal.
	HealedBuckets []string

	// ID of the current healing operation
	HealID string

	ItemsSkipped uint64
	BytesSkipped uint64

	RetryAttempts uint64

            return;
        }

        // X-Robots-Tag
        responseData.getMetaDataMap()
                .entrySet()
                .stream()
                .filter(e -> X_ROBOTS_TAG.equalsIgnoreCase(e.getKey()) && e.getValue() != null)
                .forEach(e -> {
                    boolean noindex = false;
                    boolean nofollow = false;

 * Iterator#remove} operations. This utility takes the brute-force approach of trying <i>all</i>
 * possible sequences of these operations, up to a given number of steps. So, if the caller
 * specifies to use <i>n</i> steps, a total of <i>3^n</i> tests are actually performed.
 *
 * <p>For instance, if <i>steps</i> is 5, one example sequence that will be tested is:
 *
 * <ol>
 *   <li>remove();

     *            the notifyFlags to set
     */
    public void setNotifyFlags(final int notifyFlags) {
        this.notifyFlags = notifyFlags;
    }

    /**
     * Set the completion filter specifying which changes to monitor
     *
     * @param completionFilter
     *            the completionFilter to set
     */
    public void setCompletionFilter(final int completionFilter) {

     */
    @Nullable
    Path getPath();

    /**
     * Creates a new input stream to read the source contents.
     * Each call creates a fresh stream starting from the beginning.
     * The caller is responsible for closing the returned stream.
     *
     * @return a new input stream positioned at the start of the content
     * @throws IOException if the stream cannot be created or opened
     */
    @Nonnull