snapshot.setBuildNumber(buildNumber + 1);
            } catch (RepositoryMetadataResolutionException e) {
                throw new ArtifactDeploymentException(
                        "Error retrieving previous build number for artifact '" + artifact.getDependencyConflictId()
                                + "': " + e.getMessage(),
                        e);
            }

     */
    void add(Problem.Severity severity, String message, int line, int column, Exception cause);

    /**
     * The next messages will be bound to this source. When calling this method again, previous messages keep
     * their source, but the next messages will use the new source.
     *
     * @param source a source
     */
    void setSource(String source);

    /**
     *

         * processes one artifact at a time and hence cannot associate the artifacts from the same project to use the
         * same version index. Allowing the caller to pass in metadata from a previous deployment allows to re-establish
         * the association between the artifacts of the same project.
         */
        for (Iterator<? extends Metadata> it = metadatas.iterator(); it.hasNext(); ) {

     */
    @Nonnull
    Optional<Source> locate(@Nonnull Path dir);

    /**
     * Parse the model obtained previously by a previous call to {@link #locate(Path)}.
     *
     * @param source the source to parse, never {@code null}
     * @param options possible parsing options, may be {@code null}

        <forkId implementation="int" default-value="-1">${forkId}</forkId>
      </configuration>
    </mojo>
    <mojo>
      <goal>clear-fork-context</goal>
      <description>Tear down any build state used during the previous forked execution.</description>
      <requiresDirectInvocation>false</requiresDirectInvocation>
      <requiresProject>false</requiresProject>
      <requiresReports>false</requiresReports>

         * processes one artifact at a time and hence cannot associate the artifacts from the same project to use the
         * same timestamp+buildno for the snapshot versions. Allowing the caller to pass in metadata from a previous
         * deployment allows to re-establish the association between the artifacts of the same project.
         */
        for (Metadata metadata : request.getMetadata()) {

         * processes one artifact at a time and hence cannot associate the artifacts from the same project to use the
         * same version index. Allowing the caller to pass in metadata from a previous deployment allows to re-establish
         * the association between the artifacts of the same project.
         */
        for (Iterator<? extends Metadata> it = metadatas.iterator(); it.hasNext(); ) {

import org.apache.maven.api.annotations.Nonnull;

/**
 *
 * @since 4.0.0
 */
@Experimental
public interface ArtifactManager extends Service {

    /**
     * Returns the path of the file previously associated to this artifact
     * or {@code Optional.empty()} if no path has been associated.
     */
    @Nonnull
    Optional<Path> getPath(@Nonnull Artifact artifact);

    /**

    /**
     * Uses previously stored resumption data to enrich an existing execution request.
     * @param request The execution request that will be enriched.
     * @param rootProject The root project that is being built.
     */
    void applyResumptionData(MavenExecutionRequest request, MavenProject rootProject);

    /**
     * Removes previously stored resumption data.

 * under the License.
 */
package org.apache.maven.toolchain;

import java.io.File;

import org.apache.maven.toolchain.model.PersistedToolchains;

/**
 * Builds the toolchains model from a previously configured filesystem path to the toolchains file.
 * <strong>Note:</strong> This is an internal component whose interface can change without prior notice.
 *