hasError = false;
        } else {
            hasError = true;
            errors.forEach(this.errors::add);
        }
    }

    public int getNumberOfSuggestDocs() {
        return numberOfSuggestDocs;
    }

    public int getNumberOfInputDocs() {
        return numberOfInputDocs;
    }

    public boolean hasError() {
        return hasError;
    }

        this.took = took;
        if (errors != null && !errors.isEmpty()) {
            this.errors.addAll(errors);
        }
    }

    public boolean hasError() {
        return !errors.isEmpty();
    }

    public List<Throwable> getErrors() {
        return errors;
    }

    public long getTook() {
        return took;
    }

  val onException: (IOException) -> Unit,
) : ForwardingSink(delegate) {
  private var hasErrors = false

  override fun write(
    source: Buffer,
    byteCount: Long,
  ) {
    if (hasErrors) {
      source.skip(byteCount)
      return
    }
    try {
      super.write(source, byteCount)
    } catch (e: IOException) {
      hasErrors = true
      onException(e)
    }
  }

  override fun flush() {

                problemsList.add(modelProblem);
            }

            if (result.hasErrors()) {
                hasErrors = true;
            }
        }
        return new Result<>(hasErrors, (Iterable<T>) modelsList, problemsList);
    }

    // helper to determine if problems contain error
    private static boolean hasErrors(Iterable<? extends ModelProblem> problems) {
        for (ModelProblem input : problems) {

public interface ModelProblemCollector {

    /**
     * The collected problems.
     * @return a list of model problems encountered, never {@code null}
     */
    List<ModelProblem> getProblems();

    boolean hasErrors();

    boolean hasFatalErrors();

    default void add(BuilderProblem.Severity severity, ModelProblem.Version version, String message) {
        add(severity, version, message, null, null);
    }

            severities.add(problem.getSeverity());
        }
    }

    public boolean hasFatalErrors() {
        return severities.contains(ModelProblem.Severity.FATAL);
    }

    public boolean hasErrors() {
        return severities.contains(ModelProblem.Severity.ERROR) || severities.contains(ModelProblem.Severity.FATAL);
    }

    @Override
    public List<ModelProblem> getProblems() {
        return problems;