/*
    =================== DO NOT EDIT THIS FILE ====================
    Generated by Modello 1.4.1 on 2012-01-20 18:05:12,
    any modifications will be overwritten.
    ==============================================================
    */
   
   package org.apache.maven.plugin.descriptor.model;
   
  /**
   * 
   *         A Mojo description.
   *       
   * 
   * @version $Revision$ $Date$
   */
  @SuppressWarnings( "all" )
  public class MojoDescriptor
      implements java.io.Serializable
  {
  
        //--------------------------/
       //- Class/Member Variables -/
      //--------------------------/
  
      /**
       * 
       *             The 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 annotation 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;
  
      /**
       * Field executePhase.
       */
      private String executePhase;
  
      /**
       * Field executeGoal.
       */
      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)
       *           .
       */
      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.
      */
     private boolean requiresDirectInvocation = false;
 
     /**
      * Flags this Mojo to run inside of a project.
      */
     private boolean requiresProject = true;
 
     /**
      * Flags this Mojo to require reports. 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;
 
     /**
      * 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 the executeGoal field.
      * 
      * @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 the executePhase field.
      * 
      * @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 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 annotation 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).
      * 
      * @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.
      * 
      * @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 run inside of a project.
      * 
      * @return boolean
      */
     public boolean isRequiresProject()
     {
         return this.requiresProject;
     } //-- boolean isRequiresProject()
 
     /**
      * Get flags this Mojo to require reports. 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 the executeGoal field.
      * 
      * @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 the executePhase field.
      * 
      * @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 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 annotation 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).
      * 
      * @param requiresDependencyResolution
      */
     public void setRequiresDependencyResolution( String requiresDependencyResolution )
     {
         this.requiresDependencyResolution = requiresDependencyResolution;
     } //-- void setRequiresDependencyResolution( String )
 
     /**
      * Set flags this Mojo to be invoked directly.
      * 
      * @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 run inside of a project.
      * 
      * @param requiresProject
      */
     public void setRequiresProject( boolean requiresProject )
     {
         this.requiresProject = requiresProject;
     } //-- void setRequiresProject( boolean )
 
     /**
      * Set flags this Mojo to require reports. 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 )
 
 }