// =================== DO NOT EDIT THIS FILE ====================
// Generated by Modello 1.8.1,
// any modifications will be overwritten.
// ==============================================================

package org.apache.maven.plugin.descriptor.model;

/**
 * 
 *         A Mojo description.
 *       
 * 
 * @version $Revision: 879455 $ $Date: 2013-09-22 16:29:47 +0000 (Sun, 22 Sep 2013) $
 */
@SuppressWarnings( "all" )
public class MojoDescriptor
    implements java.io.Serializable
{

      //--------------------------/
     //- Class/Member Variables -/
    //--------------------------/

    /**
     * 
     *             The goal name for the Mojo, that users will
     * reference from the command line to execute the Mojo
     * directly,
     *             or inside a POM in order to provide
     * Mojo-specific configuration.
     *           
     */
    private String goal;

    /**
     * The description of this Mojo's functionality.
     */
    private String description;

    /**
     * 
     *             The Mojo's fully-qualified class name (or script
     * path in the case of non-Java Mojos).
     *           
     */
    private String implementation;

    /**
     * The implementation language for this Mojo (java, beanshell,
     * etc.).
     */
    private String language = "java";

    /**
     * 
     *             Defines a default phase to bind a mojo execution
     * to if the user does not explicitly set a phase in the POM.
     *             <i>Note:</i> This will not automagically make a
     * mojo run when the plugin declaration is added
     *             to the POM. It merely enables the user to omit
     * the <code>&lt;phase&gt;</code> element from the
     *             surrounding <code>&lt;execution&gt;</code>
     * element.
     *           
     */
    private String phase;

    /**
     * Reference the invocation phase of the Mojo.
     */
    private String executePhase;

    /**
     * Reference the invocation goal of the Mojo.
     */
    private String executeGoal;

    /**
     * Field executeLifecycle.
     */
    private String executeLifecycle;

    /**
     * 
     *             Flags this Mojo as requiring the dependencies in
     * the specified class path to be resolved before it can
     *             execute: <code>compile</code>,
     * <code>runtime</code>, <code>test</code>,
     *             <code>compile+runtime</code> (since Maven 3.0)
     * or <code>runtime+system</code> (since Maven 3.0)
     *           .
     */
    private String requiresDependencyResolution = "runtime";

    /**
     * 
     *             Flags this mojo as requiring information about
     * the dependencies that would make up the specified class
     *             path. As the name suggests, this is similar to
     * requiresDependencyResolution and supports the same values.
     *             The important difference is this will not
     * resolve the files for the dependencies, i.e. the artifacts
     *             associated with a Maven project can lack a file.
     * As such, this annotation is meant for mojos that only
     *             want to analyze the set of transitive
     * dependencies, in particular during early lifecycle phases
     * where
     *             full dependency resolution might fail due to
     * projects which haven't been built yet.
     *           
     */
    private String requiresDependencyCollection;

    /**
     * Flags this Mojo to be invoked directly only.
     */
    private boolean requiresDirectInvocation = false;

    /**
     * Flags this Mojo to require running inside of a project.
     */
    private boolean requiresProject = true;

    /**
     * Flags this Mojo to require running inside of a reports
     * context. Unsupported since Maven 3.0.
     */
    private boolean requiresReports = false;

    /**
     * Flags this Mojo to require online mode for its operation.
     */
    private boolean requiresOnline = false;

    /**
     * 
     *             Flags this Mojo to run it in a multi module way,
     * i.e. aggregate the build with the set of projects
     *             listed as modules.
     *           
     */
    private boolean aggregator = false;

    /**
     * Specify that the Mojo is inherited.
     */
    private boolean inheritedByDefault = true;

    /**
     * 
     *             Marks this mojo as being thread-safe, i.e. the
     * mojo safely supports concurrent execution during parallel
     *             builds. Mojos without this annotation will make
     * Maven output a warning when used during a parallel build
     *             session. Since Maven 3.0.
     *           
     */
    private boolean threadSafe = false;

    /**
     * Specify the instantiation strategy.
     */
    private String instantiationStrategy = "per-lookup";

    /**
     * 
     *             Specify the execution strategy:
     * <code>once-per-session</code>, <code>always</code>.
     *           
     */
    private String executionStrategy = "once-per-session";

    /**
     * Specify the version when the Mojo was added to the API.
     * Similar to Javadoc since.
     */
    private String since;

    /**
     * 
     *             Specify the version when the Mojo was deprecated
     * to the API. Similar to Javadoc deprecated. This will
     *             trigger a warning when a user tries to configure
     * a parameter marked as deprecated.
     *           
     */
    private String deprecated;

    /**
     * 
     *             The configurator type to use when injecting
     * parameter values into this Mojo. The value is normally
     * deduced
     *             from the Mojo's implementation language, but can
     * be specified to allow a custom ComponentConfigurator
     *             implementation to be used.
     *           
     */
    private String configurator;

    /**
     * Field composer.
     */
    private String composer;

    /**
     * Field parameters.
     */
    private java.util.List<Parameter> parameters;

    /**
     * Field configuration.
     */
    private java.util.List<Configuration> configuration;

    /**
     * Field requirements.
     */
    private java.util.List<Requirement> requirements;


      //-----------/
     //- Methods -/
    //-----------/

    /**
     * Method addConfiguration.
     * 
     * @param configuration
     */
    public void addConfiguration( Configuration configuration )
    {
        getConfiguration().add( configuration );
    } //-- void addConfiguration( Configuration )

    /**
     * Method addParameter.
     * 
     * @param parameter
     */
    public void addParameter( Parameter parameter )
    {
        getParameters().add( parameter );
    } //-- void addParameter( Parameter )

    /**
     * Method addRequirement.
     * 
     * @param requirement
     */
    public void addRequirement( Requirement requirement )
    {
        getRequirements().add( requirement );
    } //-- void addRequirement( Requirement )

    /**
     * Get the composer field.
     * 
     * @return String
     */
    public String getComposer()
    {
        return this.composer;
    } //-- String getComposer()

    /**
     * Method getConfiguration.
     * 
     * @return List
     */
    public java.util.List<Configuration> getConfiguration()
    {
        if ( this.configuration == null )
        {
            this.configuration = new java.util.ArrayList<Configuration>();
        }

        return this.configuration;
    } //-- java.util.List<Configuration> getConfiguration()

    /**
     * Get the configurator type to use when injecting parameter
     * values into this Mojo. The value is normally deduced
     *             from the Mojo's implementation language, but can
     * be specified to allow a custom ComponentConfigurator
     *             implementation to be used.
     * 
     * @return String
     */
    public String getConfigurator()
    {
        return this.configurator;
    } //-- String getConfigurator()

    /**
     * Get specify the version when the Mojo was deprecated to the
     * API. Similar to Javadoc deprecated. This will
     *             trigger a warning when a user tries to configure
     * a parameter marked as deprecated.
     * 
     * @return String
     */
    public String getDeprecated()
    {
        return this.deprecated;
    } //-- String getDeprecated()

    /**
     * Get the description of this Mojo's functionality.
     * 
     * @return String
     */
    public String getDescription()
    {
        return this.description;
    } //-- String getDescription()

    /**
     * Get reference the invocation goal of the Mojo.
     * 
     * @return String
     */
    public String getExecuteGoal()
    {
        return this.executeGoal;
    } //-- String getExecuteGoal()

    /**
     * Get the executeLifecycle field.
     * 
     * @return String
     */
    public String getExecuteLifecycle()
    {
        return this.executeLifecycle;
    } //-- String getExecuteLifecycle()

    /**
     * Get reference the invocation phase of the Mojo.
     * 
     * @return String
     */
    public String getExecutePhase()
    {
        return this.executePhase;
    } //-- String getExecutePhase()

    /**
     * Get specify the execution strategy:
     * <code>once-per-session</code>, <code>always</code>.
     * 
     * @return String
     */
    public String getExecutionStrategy()
    {
        return this.executionStrategy;
    } //-- String getExecutionStrategy()

    /**
     * Get the goal name for the Mojo, that users will reference
     * from the command line to execute the Mojo directly,
     *             or inside a POM in order to provide
     * Mojo-specific configuration.
     * 
     * @return String
     */
    public String getGoal()
    {
        return this.goal;
    } //-- String getGoal()

    /**
     * Get the Mojo's fully-qualified class name (or script path in
     * the case of non-Java Mojos).
     * 
     * @return String
     */
    public String getImplementation()
    {
        return this.implementation;
    } //-- String getImplementation()

    /**
     * Get specify the instantiation strategy.
     * 
     * @return String
     */
    public String getInstantiationStrategy()
    {
        return this.instantiationStrategy;
    } //-- String getInstantiationStrategy()

    /**
     * Get the implementation language for this Mojo (java,
     * beanshell, etc.).
     * 
     * @return String
     */
    public String getLanguage()
    {
        return this.language;
    } //-- String getLanguage()

    /**
     * Method getParameters.
     * 
     * @return List
     */
    public java.util.List<Parameter> getParameters()
    {
        if ( this.parameters == null )
        {
            this.parameters = new java.util.ArrayList<Parameter>();
        }

        return this.parameters;
    } //-- java.util.List<Parameter> getParameters()

    /**
     * Get defines a default phase to bind a mojo execution to if
     * the user does not explicitly set a phase in the POM.
     *             <i>Note:</i> This will not automagically make a
     * mojo run when the plugin declaration is added
     *             to the POM. It merely enables the user to omit
     * the <code>&lt;phase&gt;</code> element from the
     *             surrounding <code>&lt;execution&gt;</code>
     * element.
     * 
     * @return String
     */
    public String getPhase()
    {
        return this.phase;
    } //-- String getPhase()

    /**
     * Method getRequirements.
     * 
     * @return List
     */
    public java.util.List<Requirement> getRequirements()
    {
        if ( this.requirements == null )
        {
            this.requirements = new java.util.ArrayList<Requirement>();
        }

        return this.requirements;
    } //-- java.util.List<Requirement> getRequirements()

    /**
     * Get flags this mojo as requiring information about the
     * dependencies that would make up the specified class
     *             path. As the name suggests, this is similar to
     * requiresDependencyResolution and supports the same values.
     *             The important difference is this will not
     * resolve the files for the dependencies, i.e. the artifacts
     *             associated with a Maven project can lack a file.
     * As such, this annotation is meant for mojos that only
     *             want to analyze the set of transitive
     * dependencies, in particular during early lifecycle phases
     * where
     *             full dependency resolution might fail due to
     * projects which haven't been built yet.
     * 
     * @return String
     */
    public String getRequiresDependencyCollection()
    {
        return this.requiresDependencyCollection;
    } //-- String getRequiresDependencyCollection()

    /**
     * Get flags this Mojo as requiring the dependencies in the
     * specified class path to be resolved before it can
     *             execute: <code>compile</code>,
     * <code>runtime</code>, <code>test</code>,
     *             <code>compile+runtime</code> (since Maven 3.0)
     * or <code>runtime+system</code> (since Maven 3.0).
     * 
     * @return String
     */
    public String getRequiresDependencyResolution()
    {
        return this.requiresDependencyResolution;
    } //-- String getRequiresDependencyResolution()

    /**
     * Get specify the version when the Mojo was added to the API.
     * Similar to Javadoc since.
     * 
     * @return String
     */
    public String getSince()
    {
        return this.since;
    } //-- String getSince()

    /**
     * Get flags this Mojo to run it in a multi module way, i.e.
     * aggregate the build with the set of projects
     *             listed as modules.
     * 
     * @return boolean
     */
    public boolean isAggregator()
    {
        return this.aggregator;
    } //-- boolean isAggregator()

    /**
     * Get specify that the Mojo is inherited.
     * 
     * @return boolean
     */
    public boolean isInheritedByDefault()
    {
        return this.inheritedByDefault;
    } //-- boolean isInheritedByDefault()

    /**
     * Get flags this Mojo to be invoked directly only.
     * 
     * @return boolean
     */
    public boolean isRequiresDirectInvocation()
    {
        return this.requiresDirectInvocation;
    } //-- boolean isRequiresDirectInvocation()

    /**
     * Get flags this Mojo to require online mode for its
     * operation.
     * 
     * @return boolean
     */
    public boolean isRequiresOnline()
    {
        return this.requiresOnline;
    } //-- boolean isRequiresOnline()

    /**
     * Get flags this Mojo to require running inside of a project.
     * 
     * @return boolean
     */
    public boolean isRequiresProject()
    {
        return this.requiresProject;
    } //-- boolean isRequiresProject()

    /**
     * Get flags this Mojo to require running inside of a reports
     * context. Unsupported since Maven 3.0.
     * 
     * @return boolean
     */
    public boolean isRequiresReports()
    {
        return this.requiresReports;
    } //-- boolean isRequiresReports()

    /**
     * Get marks this mojo as being thread-safe, i.e. the mojo
     * safely supports concurrent execution during parallel
     *             builds. Mojos without this annotation will make
     * Maven output a warning when used during a parallel build
     *             session. Since Maven 3.0.
     * 
     * @return boolean
     */
    public boolean isThreadSafe()
    {
        return this.threadSafe;
    } //-- boolean isThreadSafe()

    /**
     * Method removeConfiguration.
     * 
     * @param configuration
     */
    public void removeConfiguration( Configuration configuration )
    {
        getConfiguration().remove( configuration );
    } //-- void removeConfiguration( Configuration )

    /**
     * Method removeParameter.
     * 
     * @param parameter
     */
    public void removeParameter( Parameter parameter )
    {
        getParameters().remove( parameter );
    } //-- void removeParameter( Parameter )

    /**
     * Method removeRequirement.
     * 
     * @param requirement
     */
    public void removeRequirement( Requirement requirement )
    {
        getRequirements().remove( requirement );
    } //-- void removeRequirement( Requirement )

    /**
     * Set flags this Mojo to run it in a multi module way, i.e.
     * aggregate the build with the set of projects
     *             listed as modules.
     * 
     * @param aggregator
     */
    public void setAggregator( boolean aggregator )
    {
        this.aggregator = aggregator;
    } //-- void setAggregator( boolean )

    /**
     * Set the composer field.
     * 
     * @param composer
     */
    public void setComposer( String composer )
    {
        this.composer = composer;
    } //-- void setComposer( String )

    /**
     * Set the configuration field.
     * 
     * @param configuration
     */
    public void setConfiguration( java.util.List<Configuration> configuration )
    {
        this.configuration = configuration;
    } //-- void setConfiguration( java.util.List )

    /**
     * Set the configurator type to use when injecting parameter
     * values into this Mojo. The value is normally deduced
     *             from the Mojo's implementation language, but can
     * be specified to allow a custom ComponentConfigurator
     *             implementation to be used.
     * 
     * @param configurator
     */
    public void setConfigurator( String configurator )
    {
        this.configurator = configurator;
    } //-- void setConfigurator( String )

    /**
     * Set specify the version when the Mojo was deprecated to the
     * API. Similar to Javadoc deprecated. This will
     *             trigger a warning when a user tries to configure
     * a parameter marked as deprecated.
     * 
     * @param deprecated
     */
    public void setDeprecated( String deprecated )
    {
        this.deprecated = deprecated;
    } //-- void setDeprecated( String )

    /**
     * Set the description of this Mojo's functionality.
     * 
     * @param description
     */
    public void setDescription( String description )
    {
        this.description = description;
    } //-- void setDescription( String )

    /**
     * Set reference the invocation goal of the Mojo.
     * 
     * @param executeGoal
     */
    public void setExecuteGoal( String executeGoal )
    {
        this.executeGoal = executeGoal;
    } //-- void setExecuteGoal( String )

    /**
     * Set the executeLifecycle field.
     * 
     * @param executeLifecycle
     */
    public void setExecuteLifecycle( String executeLifecycle )
    {
        this.executeLifecycle = executeLifecycle;
    } //-- void setExecuteLifecycle( String )

    /**
     * Set reference the invocation phase of the Mojo.
     * 
     * @param executePhase
     */
    public void setExecutePhase( String executePhase )
    {
        this.executePhase = executePhase;
    } //-- void setExecutePhase( String )

    /**
     * Set specify the execution strategy:
     * <code>once-per-session</code>, <code>always</code>.
     * 
     * @param executionStrategy
     */
    public void setExecutionStrategy( String executionStrategy )
    {
        this.executionStrategy = executionStrategy;
    } //-- void setExecutionStrategy( String )

    /**
     * Set the goal name for the Mojo, that users will reference
     * from the command line to execute the Mojo directly,
     *             or inside a POM in order to provide
     * Mojo-specific configuration.
     * 
     * @param goal
     */
    public void setGoal( String goal )
    {
        this.goal = goal;
    } //-- void setGoal( String )

    /**
     * Set the Mojo's fully-qualified class name (or script path in
     * the case of non-Java Mojos).
     * 
     * @param implementation
     */
    public void setImplementation( String implementation )
    {
        this.implementation = implementation;
    } //-- void setImplementation( String )

    /**
     * Set specify that the Mojo is inherited.
     * 
     * @param inheritedByDefault
     */
    public void setInheritedByDefault( boolean inheritedByDefault )
    {
        this.inheritedByDefault = inheritedByDefault;
    } //-- void setInheritedByDefault( boolean )

    /**
     * Set specify the instantiation strategy.
     * 
     * @param instantiationStrategy
     */
    public void setInstantiationStrategy( String instantiationStrategy )
    {
        this.instantiationStrategy = instantiationStrategy;
    } //-- void setInstantiationStrategy( String )

    /**
     * Set the implementation language for this Mojo (java,
     * beanshell, etc.).
     * 
     * @param language
     */
    public void setLanguage( String language )
    {
        this.language = language;
    } //-- void setLanguage( String )

    /**
     * Set the parameters field.
     * 
     * @param parameters
     */
    public void setParameters( java.util.List<Parameter> parameters )
    {
        this.parameters = parameters;
    } //-- void setParameters( java.util.List )

    /**
     * Set defines a default phase to bind a mojo execution to if
     * the user does not explicitly set a phase in the POM.
     *             <i>Note:</i> This will not automagically make a
     * mojo run when the plugin declaration is added
     *             to the POM. It merely enables the user to omit
     * the <code>&lt;phase&gt;</code> element from the
     *             surrounding <code>&lt;execution&gt;</code>
     * element.
     * 
     * @param phase
     */
    public void setPhase( String phase )
    {
        this.phase = phase;
    } //-- void setPhase( String )

    /**
     * Set the requirements field.
     * 
     * @param requirements
     */
    public void setRequirements( java.util.List<Requirement> requirements )
    {
        this.requirements = requirements;
    } //-- void setRequirements( java.util.List )

    /**
     * Set flags this mojo as requiring information about the
     * dependencies that would make up the specified class
     *             path. As the name suggests, this is similar to
     * requiresDependencyResolution and supports the same values.
     *             The important difference is this will not
     * resolve the files for the dependencies, i.e. the artifacts
     *             associated with a Maven project can lack a file.
     * As such, this annotation is meant for mojos that only
     *             want to analyze the set of transitive
     * dependencies, in particular during early lifecycle phases
     * where
     *             full dependency resolution might fail due to
     * projects which haven't been built yet.
     * 
     * @param requiresDependencyCollection
     */
    public void setRequiresDependencyCollection( String requiresDependencyCollection )
    {
        this.requiresDependencyCollection = requiresDependencyCollection;
    } //-- void setRequiresDependencyCollection( String )

    /**
     * Set flags this Mojo as requiring the dependencies in the
     * specified class path to be resolved before it can
     *             execute: <code>compile</code>,
     * <code>runtime</code>, <code>test</code>,
     *             <code>compile+runtime</code> (since Maven 3.0)
     * or <code>runtime+system</code> (since Maven 3.0).
     * 
     * @param requiresDependencyResolution
     */
    public void setRequiresDependencyResolution( String requiresDependencyResolution )
    {
        this.requiresDependencyResolution = requiresDependencyResolution;
    } //-- void setRequiresDependencyResolution( String )

    /**
     * Set flags this Mojo to be invoked directly only.
     * 
     * @param requiresDirectInvocation
     */
    public void setRequiresDirectInvocation( boolean requiresDirectInvocation )
    {
        this.requiresDirectInvocation = requiresDirectInvocation;
    } //-- void setRequiresDirectInvocation( boolean )

    /**
     * Set flags this Mojo to require online mode for its
     * operation.
     * 
     * @param requiresOnline
     */
    public void setRequiresOnline( boolean requiresOnline )
    {
        this.requiresOnline = requiresOnline;
    } //-- void setRequiresOnline( boolean )

    /**
     * Set flags this Mojo to require running inside of a project.
     * 
     * @param requiresProject
     */
    public void setRequiresProject( boolean requiresProject )
    {
        this.requiresProject = requiresProject;
    } //-- void setRequiresProject( boolean )

    /**
     * Set flags this Mojo to require running inside of a reports
     * context. Unsupported since Maven 3.0.
     * 
     * @param requiresReports
     */
    public void setRequiresReports( boolean requiresReports )
    {
        this.requiresReports = requiresReports;
    } //-- void setRequiresReports( boolean )

    /**
     * Set specify the version when the Mojo was added to the API.
     * Similar to Javadoc since.
     * 
     * @param since
     */
    public void setSince( String since )
    {
        this.since = since;
    } //-- void setSince( String )

    /**
     * Set marks this mojo as being thread-safe, i.e. the mojo
     * safely supports concurrent execution during parallel
     *             builds. Mojos without this annotation will make
     * Maven output a warning when used during a parallel build
     *             session. Since Maven 3.0.
     * 
     * @param threadSafe
     */
    public void setThreadSafe( boolean threadSafe )
    {
        this.threadSafe = threadSafe;
    } //-- void setThreadSafe( boolean )

}