QueryBuilders.functionScoreQuery(QueryBuilders.matchAllQuery(),
                            new FunctionScoreQueryBuilder.FilterFunctionBuilder[] { new FunctionScoreQueryBuilder.FilterFunctionBuilder(
                                    new RandomScoreFunctionBuilder().seed(sessionId.hashCode())) }),
                    0, pollingFetchSize, SortBuilders.scoreSort().order(SortOrder.DESC));

        }
        return false;
    }

    @Override
    public E next() {
        if (!hasNext()) {
            throw new NoSuchElementException();
        }
        return iterators[index].next();
    }

    @Override
    public void remove() {
        throw new ClUnsupportedOperationException("remove");
    }

 */
public class SuggestSettingsBuilder {
    /**
     * Constructs a new {@link SuggestSettingsBuilder}.
     */
    public SuggestSettingsBuilder() {
        // nothing
    }

    /** The settings index name. */
    protected String settingsIndexName = "fess_suggest";

    /** The timeout settings. */
    protected TimeoutSettings timeoutSettings = new TimeoutSettings();

    /** The initial settings. */

   */

  @Override
  public void write(char[] cbuf, int off, int len) throws IOException {
    checkNotClosed();
    // It turns out that creating a new String is usually as fast, or faster
    // than wrapping cbuf in a light-weight CharSequence.
    target.append(new String(cbuf, off, len));
  }

  /*
   * Override a few functions for performance reasons to avoid creating unnecessary strings.
   */

  @Override

                        handler.isIncludesDependencies(),
                        handler.isAddedToClasspath()
                                ? new JavaPathType[] {JavaPathType.CLASSES, JavaPathType.MODULES}
                                : new JavaPathType[] {});
            }
            return type;
        });
    }

            try (InputStream is = Files.newInputStream(pom)) {
                MavenStaxReader reader = new MavenStaxReader();
                reader.setAddLocationInformation(false);
                reader.read(is, true, InputSource.of("id", pom.toString()));
                i++;
            } catch (XMLStreamException e) {
                throw new RuntimeException("Error parsing: " + pom, e);
            }
        }
        return i;
    }

     * @return The user-friendly source hint, never {@code null}.
     */
    static String toSourceHint(Model model) {
        if (model == null) {
            return "";
        }

        StringBuilder buffer = new StringBuilder(128);

        buffer.append(toId(model));

        File pomFile = model.getPomFile();
        if (pomFile != null) {
            buffer.append(" (").append(pomFile).append(')');
        }

     */
    @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
     */

 */
public abstract class LayeredOptions<O extends Options> implements Options {
    protected final List<O> options;

    protected LayeredOptions(List<O> options) {
        this.options = new ArrayList<>(options);
    }

    @Override
    public Optional<Map<String, String>> userProperties() {
        return collectMapIfPresentOrEmpty(Options::userProperties);
    }

    @Override

    private ParseOverflowDetection() {}

    // calculated as 0xffffffffffffffff / radix
    static final long[] maxValueDivs = new long[Character.MAX_RADIX + 1];
    static final int[] maxValueMods = new int[Character.MAX_RADIX + 1];
    static final int[] maxSafeDigits = new int[Character.MAX_RADIX + 1];

    static {
      BigInteger overflow = BigInteger.ONE.shiftLeft(64);