/**
 * <p>
 * A {@link Builder} encapsulates a strategy for building a set of Maven projects. The default strategy in Maven builds
 * the projects serially, but a {@link Builder} can employ any type of concurrency model to build the projects.
 */
@Named("singlethreaded")
@Singleton
public class SingleThreadedBuilder implements Builder {
    private final LifecycleModuleBuilder lifecycleModuleBuilder;

    @Inject

 * from the plugin configuration or from other components.
 *
 * @since 4.0.0
 */
@Experimental
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Inherited
public @interface Mojo {
    /**
     * goal name (required).
     * @return the goal name
     */
    @Nonnull
    String name();

    /**
     * default phase to bind your mojo.

import org.apache.maven.artifact.handler.ArtifactHandler;

/**
 */
public interface ArtifactHandlerManager {
    String ROLE = ArtifactHandlerManager.class.getName();

    ArtifactHandler getArtifactHandler(String type);

    @Deprecated
    void addHandlers(Map<String, ArtifactHandler> handlers);

 * specific language governing permissions and limitations
 * under the License.
 */
package org.apache.maven.artifact;

import java.util.HashMap;
import java.util.Map;

/**
 * Type safe enumeration for the artifact status field.
 *
 */
@Deprecated
public final class ArtifactStatus implements Comparable<ArtifactStatus> {
    /**
     * No trust - no information about status.
     */

        buffer.append(LS).append("GroupId: ").append(getGroupId());
        buffer.append(LS).append("ArtifactId: ").append(getArtifactId());
        buffer.append(LS).append("Metadata Type: ").append(getClass().getName());

        return buffer.toString();
    }

    /**
     * Password associated with the proxy server
     */
    private String password;

    /**
     * Proxy server port
     */
    private int port;

    /**
     * Type of the proxy
     */
    private String protocol;

    /**
     * The non-proxy hosts. Follows Java system property format: <code>*.foo.com|localhost</code>.
     */
    private String nonProxyHosts;

    /**

/**
 * Used if your Mojo needs to fork a <a href="/ref/3.0.4/maven-core/lifecycles.html">lifecycle</a>.
 *
 * @since 4.0.0
 */
@Experimental
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Inherited
public @interface Execute {
    /**
     * Lifecycle phase to fork. Note that specifying a phase overrides specifying a goal.
     * @return the phase
     */
    @Nonnull
    String phase() default "";

        /*
         * Grab plugin executions that are bound to the selected lifecycle phases from project. The effective model of
         * the project already contains the plugin executions induced by the project's packaging type. Remember, all
         * phases of interest and only those are in the lifecycle mapping, if a phase has no value in the map, we are
         * not interested in any of the executions bound to it.
         */

            boolean isCollection = false;
            boolean isMap = false;
            boolean isProperties = false;
            if (!isArray) {
                try {
                    // assuming Type is available in current ClassLoader
                    isCollection = Collection.class.isAssignableFrom(Class.forName(param.getType()));
                    isMap = Map.class.isAssignableFrom(Class.forName(param.getType()));

     * for finalName directly in the plugin configuration section. It is also useful to ensure that - for example - a
     * List-typed parameter which expects items of type Artifact doesn't get a List full of Strings.
     *
     * @return <code>true</code> if the user should not be allowed to configure the parameter directly
     */
    boolean readonly() default false;