sb.append(problem.getSeverity());
                sb.append("] ");
                sb.append(problem.getMessage());
                String loc = Stream.of(
                                problem.getModelId().equals(modelId) ? problem.getModelId() : "",
                                problem.getModelId().equals(modelId) ? problem.getSource() : "",

                        return defaultModelBuilder.readRawModel(gaBuildingRequest, problems);
                    } catch (ModelBuilderException e) {
                        // gathered with problem collector
                    }
                }
                return null;
            }

            private void loadFullReactor() {
                if (!fullReactorLoaded) {

            if (cause instanceof ModelBuildingException) {
                String message = "In: " + pom + "\n\n";
                for (ModelProblem problem : ((ModelBuildingException) cause).getProblems()) {
                    message += problem + "\n";
                }
                System.out.println(message);
                fail(message);
            }

            throw e;
        }
    }

     * @return The calculated checksums, indexed by algorithms, never {@code null}.
     * @throws NullPointerException if passed in any parameter is {@code null}.
     * @throws IOException In case of any IO problem.
     */
    @Nonnull
    Map<ChecksumAlgorithm, String> calculate(@Nonnull Path file, @Nonnull Collection<ChecksumAlgorithm> algorithms)
            throws IOException;

    /**

    }

    private boolean hasErrors(List<BuilderProblem> problems) {
        if (problems != null) {
            for (BuilderProblem problem : problems) {
                if (BuilderProblem.Severity.ERROR.compareTo(problem.getSeverity()) >= 0) {
                    return true;
                }
            }
        }

        return false;
    }

            // and this could lead to cycles where a thread waits for
            // a task to finish, then execute another one which waits
            // for the initial task...
            // In order to work around that problem, we override the
            // invokeAll method, so that whenever the method is called,
            // the pool core size will be incremented before submitting

/**
 * Describes a problem that was encountered during project building. A problem can either be an exception that was
 * thrown or a simple string message. In addition, a problem carries a hint about its source.
 *
 * @since 4.0.0
 */
@Experimental
@Immutable
public interface BuilderProblem {

    /**

        private final org.apache.maven.building.Problem problem;

        MappedBuilderProblem(org.apache.maven.building.Problem problem) {
            this.problem = problem;
        }

        @Override
        public String getSource() {
            return problem.getSource();
        }

        @Override
        public int getLineNumber() {
            return problem.getLineNumber();
        }

        private final SettingsProblem problem;

        MappedBuilderProblem(SettingsProblem problem) {
            this.problem = problem;
        }

        @Override
        public String getSource() {
            return problem.getSource();
        }

        @Override
        public int getLineNumber() {
            return problem.getLineNumber();
        }

        @Override

 */
public interface ProblemCollector {

    /**
     * Adds the specified problem.
     * Either message or exception is required
     *
     * @param severity The severity of the problem, must not be {@code null}.
     * @param message The detail message of the problem, may be {@code null}.
     * @param line The one-based index of the line containing the problem or {@code -1} if unknown.