MojoDescriptor

java.lang.Object
- org.codehaus.plexus.component.repository.ComponentDescriptor<Mojo>
- - org.apache.maven.plugin.descriptor.MojoDescriptor

All Implemented Interfaces:

java.lang.Cloneable
```
public class MojoDescriptor
extends org.codehaus.plexus.component.repository.ComponentDescriptor<Mojo>
implements java.lang.Cloneable
```
The bean containing the Mojo descriptor.
For more information about the usage tag, have a look to: https://maven.apache.org/developers/mojo-api-specification.html TODO is there a need for the delegation of MavenMojoDescriptor to this? Why not just extend ComponentDescriptor here?

Field Summary

Fields
Modifier and Type	Field and Description
`private boolean`	`aggregator` Flags this Mojo to run it in a multi module way, i.e.
`private static java.lang.String`	`DEFAULT_INSTANTIATION_STRATEGY`
`private static java.lang.String`	`DEFAULT_LANGUAGE`
`private java.lang.String`	`dependencyCollectionRequired` The scope of (transitive) dependencies that should be collected but not resolved.
`private java.lang.String`	`dependencyResolutionRequired` Specify the required dependencies in a specified scope
`private java.lang.String`	`deprecated` Specify the version when the Mojo was deprecated to the API.
`private boolean`	`directInvocationOnly` By default, the Mojo cannot be invoked directly
`private java.lang.String`	`executeGoal` Reference the invocation goal of the Mojo.
`private java.lang.String`	`executeLifecycle` Reference the invocation lifecycle of the Mojo.
`private java.lang.String`	`executePhase` Reference the invocation phase of the Mojo.
`private java.lang.String`	`executionStrategy` By default, the execution strategy is "once-per-session"
`private java.lang.String`	`goal` 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 boolean`	`inheritedByDefault` By default, the Mojo is inherited
`static java.lang.String`	`MAVEN_PLUGIN` The Plexus component type
`private org.codehaus.plexus.configuration.PlexusConfiguration`	`mojoConfiguration` Plugin configuration
`static java.lang.String`	`MULTI_PASS_EXEC_STRATEGY` "always" execution strategy
`private boolean`	`onlineRequired` By default, the Mojo is assumed to work offline as well
`private java.util.Map<java.lang.String,Parameter>`	`parameterMap`
`private java.util.List<Parameter>`	`parameters`
`private java.lang.String`	`phase` Defines a default phase to bind a mojo execution to if the user does not explicitly set a phase in the POM.
`private PluginDescriptor`	`pluginDescriptor` Plugin descriptor
`private boolean`	`projectRequired` By default, the Mojo needs a Maven project to be executed
`private boolean`	`requiresReports` By default, the Mojo don't need reports to run
`private java.lang.String`	`since` Specify the version when the Mojo was added to the API.
`static java.lang.String`	`SINGLE_PASS_EXEC_STRATEGY` "once-per-session" execution strategy
`private boolean`	`threadSafe` By default, mojos are not threadsafe

Constructor Summary

Constructors
Constructor and Description

MojoDescriptor()
Default constructor.

Constructors
Constructor and Description
`MojoDescriptor()` Default constructor.

Method Summary

All Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`void`	`addParameter(Parameter parameter)`
`boolean`	`alwaysExecute()`
`MojoDescriptor`	`clone()` Creates a shallow copy of this mojo descriptor.
`private boolean`	`compareObjects(java.lang.Object first, java.lang.Object second)`
`boolean`	`equals(java.lang.Object object)`
`java.lang.String`	`getComponentType()`
`java.lang.String`	`getDependencyCollectionRequired()` Gets the scope of (transitive) dependencies that should be collected.
`java.lang.String`	`getDependencyResolutionRequired()`
`java.lang.String`	`getDeprecated()`
`java.lang.String`	`getExecuteGoal()`
`java.lang.String`	`getExecuteLifecycle()`
`java.lang.String`	`getExecutePhase()`
`java.lang.String`	`getExecutionStrategy()`
`java.lang.String`	`getFullGoalName()`
`java.lang.String`	`getGoal()`
`java.lang.String`	`getId()`
`java.lang.String`	`getLanguage()`
`org.codehaus.plexus.configuration.PlexusConfiguration`	`getMojoConfiguration()`
`java.util.Map<java.lang.String,Parameter>`	`getParameterMap()`
`java.util.List<Parameter>`	`getParameters()`
`java.lang.String`	`getPhase()`
`PluginDescriptor`	`getPluginDescriptor()`
`java.lang.String`	`getRole()`
`java.lang.String`	`getRoleHint()`
`java.lang.String`	`getSince()`
`int`	`hashCode()`
`boolean`	`isAggregator()`
`java.lang.String`	`isDependencyResolutionRequired()` Deprecated.
`boolean`	`isDirectInvocationOnly()`
`boolean`	`isForking()`
`boolean`	`isInheritedByDefault()`
`boolean`	`isOnlineRequired()`
`boolean`	`isProjectRequired()`
`boolean`	`isRequiresReports()`
`boolean`	`isThreadSafe()`
`boolean`	`requiresOnline()`
`void`	`setAggregator(boolean aggregator)`
`void`	`setDependencyCollectionRequired(java.lang.String requiresDependencyCollection)`
`void`	`setDependencyResolutionRequired(java.lang.String requiresDependencyResolution)`
`void`	`setDeprecated(java.lang.String deprecated)`
`void`	`setDirectInvocationOnly(boolean directInvocationOnly)`
`void`	`setExecuteGoal(java.lang.String executeGoal)`
`void`	`setExecuteLifecycle(java.lang.String executeLifecycle)`
`void`	`setExecutePhase(java.lang.String executePhase)`
`void`	`setExecutionStrategy(java.lang.String executionStrategy)`
`void`	`setGoal(java.lang.String goal)`
`void`	`setInheritedByDefault(boolean inheritedByDefault)`
`void`	`setLanguage(java.lang.String language)`
`void`	`setMojoConfiguration(org.codehaus.plexus.configuration.PlexusConfiguration mojoConfiguration)`
`void`	`setOnlineRequired(boolean requiresOnline)`
`void`	`setParameters(java.util.List<Parameter> parameters)`
`void`	`setPhase(java.lang.String phase)`
`void`	`setPluginDescriptor(PluginDescriptor pluginDescriptor)`
`void`	`setProjectRequired(boolean requiresProject)`
`void`	`setRequiresReports(boolean requiresReports)`
`void`	`setSince(java.lang.String since)`
`void`	`setThreadSafe(boolean threadSafe)`

Methods inherited from class org.codehaus.plexus.component.repository.ComponentDescriptor
addRequirement, getAlias, getComponentComposer, getComponentConfigurator, getComponentFactory, getComponentProfile, getConfiguration, getDescription, getHumanReadableKey, getImplementation, getImplementationClass, getInstantiationStrategy, getLifecycleHandler, getRealm, getRequirements, getRoleClass, getVersion, hasConfiguration, isIsolatedRealm, setAlias, setComponentComposer, setComponentConfigurator, setComponentFactory, setComponentProfile, setComponentType, setConfiguration, setDescription, setImplementation, setImplementationClass, setInstantiationStrategy, setIsolatedRealm, setLifecycleHandler, setRealm, setRole, setRoleClass, setRoleHint, setVersion, toString

Methods inherited from class java.lang.Object
finalize, getClass, notify, notifyAll, wait, wait, wait

- Field Detail
  - MAVEN_PLUGIN
```
public static final java.lang.String MAVEN_PLUGIN
```
    The Plexus component type
    
    See Also:
    
    Constant Field Values
  - SINGLE_PASS_EXEC_STRATEGY
```
public static final java.lang.String SINGLE_PASS_EXEC_STRATEGY
```
    "once-per-session" execution strategy
    
    See Also:
    
    Constant Field Values
  - MULTI_PASS_EXEC_STRATEGY
```
public static final java.lang.String MULTI_PASS_EXEC_STRATEGY
```
    "always" execution strategy
    
    See Also:
    
    Constant Field Values
  - DEFAULT_INSTANTIATION_STRATEGY
```
private static final java.lang.String DEFAULT_INSTANTIATION_STRATEGY
```
    See Also:
    
    Constant Field Values
  - DEFAULT_LANGUAGE
```
private static final java.lang.String DEFAULT_LANGUAGE
```
    See Also:
    
    Constant Field Values
  - parameters
```
private java.util.List<Parameter> parameters
```
  - parameterMap
```
private java.util.Map<java.lang.String,Parameter> parameterMap
```
  - executionStrategy
```
private java.lang.String executionStrategy
```
    By default, the execution strategy is "once-per-session"
  - goal
```
private java.lang.String goal
```
    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.
  - phase
```
private java.lang.String phase
```
    Defines a default phase to bind a mojo execution to if the user does not explicitly set a phase in the POM. Note: 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 <phase> element from the surrounding <execution> element.
  - since
```
private java.lang.String since
```
    Specify the version when the Mojo was added to the API. Similar to Javadoc since.
  - executePhase
```
private java.lang.String executePhase
```
    Reference the invocation phase of the Mojo.
  - executeGoal
```
private java.lang.String executeGoal
```
    Reference the invocation goal of the Mojo.
  - executeLifecycle
```
private java.lang.String executeLifecycle
```
    Reference the invocation lifecycle of the Mojo.
  - deprecated
```
private java.lang.String deprecated
```
    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.
  - aggregator
```
private boolean aggregator
```
    Flags this Mojo to run it in a multi module way, i.e. aggregate the build with the set of projects listed as modules. By default, no need to aggregate the Maven project and its child modules
  - dependencyResolutionRequired
```
private java.lang.String dependencyResolutionRequired
```
    Specify the required dependencies in a specified scope
  - dependencyCollectionRequired
```
private java.lang.String dependencyCollectionRequired
```
    The scope of (transitive) dependencies that should be collected but not resolved.
    
    Since:
    
    3.0-alpha-3
  - projectRequired
```
private boolean projectRequired
```
    By default, the Mojo needs a Maven project to be executed
  - onlineRequired
```
private boolean onlineRequired
```
    By default, the Mojo is assumed to work offline as well
  - mojoConfiguration
```
private org.codehaus.plexus.configuration.PlexusConfiguration mojoConfiguration
```
    Plugin configuration
  - pluginDescriptor
```
private PluginDescriptor pluginDescriptor
```
    Plugin descriptor
  - inheritedByDefault
```
private boolean inheritedByDefault
```
    By default, the Mojo is inherited
  - directInvocationOnly
```
private boolean directInvocationOnly
```
    By default, the Mojo cannot be invoked directly
  - requiresReports
```
private boolean requiresReports
```
    By default, the Mojo don't need reports to run
  - threadSafe
```
private boolean threadSafe
```
    By default, mojos are not threadsafe
    
    Since:
    
    3.0-beta-2
- Constructor Detail
  - MojoDescriptor
```
public MojoDescriptor()
```
    Default constructor.
- Method Detail
  - getLanguage
```
public java.lang.String getLanguage()
```
    Returns:
    
    the language of this Mojo, i.e. java
  - setLanguage
```
public void setLanguage(java.lang.String language)
```
    Parameters:
    
    language - the new language
  - getDeprecated
```
public java.lang.String getDeprecated()
```
    Returns:
    
    true if the Mojo is deprecated, false otherwise.
  - setDeprecated
```
public void setDeprecated(java.lang.String deprecated)
```
    Parameters:
    
    deprecated - true to deprecate the Mojo, false otherwise.
  - getParameters
```
public java.util.List<Parameter> getParameters()
```
    Returns:
    
    the list of parameters
  - setParameters
```
public void setParameters(java.util.List<Parameter> parameters)
                   throws DuplicateParameterException
```
    Parameters:
    
    parameters - the new list of parameters
    
    Throws:
    
    DuplicateParameterException - if any
  - addParameter
```
public void addParameter(Parameter parameter)
                  throws DuplicateParameterException
```
    Parameters:
    
    parameter - add a new parameter
    
    Throws:
    
    DuplicateParameterException - if any
  - getParameterMap
```
public java.util.Map<java.lang.String,Parameter> getParameterMap()
```
    Returns:
    
    the list parameters as a Map
  - setDependencyResolutionRequired
```
public void setDependencyResolutionRequired(java.lang.String requiresDependencyResolution)
```
    Parameters:
    
    requiresDependencyResolution - the new required dependencies in a specified scope
  - getDependencyResolutionRequired
```
public java.lang.String getDependencyResolutionRequired()
```
  - isDependencyResolutionRequired
```
@Deprecated
public java.lang.String isDependencyResolutionRequired()
```
    Deprecated.
    
    Returns:
    
    the required dependencies in a specified scope TODO the name is not intelligible
  - setDependencyCollectionRequired
```
public void setDependencyCollectionRequired(java.lang.String requiresDependencyCollection)
```
    Since:
    
    3.0-alpha-3
  - getDependencyCollectionRequired
```
public java.lang.String getDependencyCollectionRequired()
```
    Gets the scope of (transitive) dependencies that should be collected. Dependency collection refers to the process of calculating the complete dependency tree in terms of artifact coordinates. In contrast to dependency resolution, this does not include the download of the files for the dependency artifacts. It 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.
    
    Returns:
    
    The scope of (transitive) dependencies that should be collected or null if none.
    
    Since:
    
    3.0-alpha-3
  - setProjectRequired
```
public void setProjectRequired(boolean requiresProject)
```
    Parameters:
    
    requiresProject - true if the Mojo needs a Maven project to be executed, false otherwise.
  - isProjectRequired
```
public boolean isProjectRequired()
```
    Returns:
    
    true if the Mojo needs a Maven project to be executed, false otherwise.
  - setOnlineRequired
```
public void setOnlineRequired(boolean requiresOnline)
```
    Parameters:
    
    requiresOnline - true if the Mojo is online, false otherwise.
  - isOnlineRequired
```
public boolean isOnlineRequired()
```
    Returns:
    
    true if the Mojo is online, false otherwise.
  - requiresOnline
```
public boolean requiresOnline()
```
    Returns:
    
    true if the Mojo is online, false otherwise.
  - getPhase
```
public java.lang.String getPhase()
```
    Returns:
    
    the binded phase name of the Mojo
  - setPhase
```
public void setPhase(java.lang.String phase)
```
    Parameters:
    
    phase - the new binded phase name of the Mojo
  - getSince
```
public java.lang.String getSince()
```
    Returns:
    
    the version when the Mojo was added to the API
  - setSince
```
public void setSince(java.lang.String since)
```
    Parameters:
    
    since - the new version when the Mojo was added to the API
  - getGoal
```
public java.lang.String getGoal()
```
    Returns:
    
    The goal name of the Mojo
  - setGoal
```
public void setGoal(java.lang.String goal)
```
    Parameters:
    
    goal - The new goal name of the Mojo
  - getExecutePhase
```
public java.lang.String getExecutePhase()
```
    Returns:
    
    the invocation phase of the Mojo
  - setExecutePhase
```
public void setExecutePhase(java.lang.String executePhase)
```
    Parameters:
    
    executePhase - the new invocation phase of the Mojo
  - alwaysExecute
```
public boolean alwaysExecute()
```
    Returns:
    
    true if the Mojo uses always for the executionStrategy
  - getExecutionStrategy
```
public java.lang.String getExecutionStrategy()
```
    Returns:
    
    the execution strategy
  - setExecutionStrategy
```
public void setExecutionStrategy(java.lang.String executionStrategy)
```
    Parameters:
    
    executionStrategy - the new execution strategy
  - getMojoConfiguration
```
public org.codehaus.plexus.configuration.PlexusConfiguration getMojoConfiguration()
```
    Returns:
    
    the mojo configuration
  - setMojoConfiguration
```
public void setMojoConfiguration(org.codehaus.plexus.configuration.PlexusConfiguration mojoConfiguration)
```
    Parameters:
    
    mojoConfiguration - a new mojo configuration
  - getRole
```
public java.lang.String getRole()
```
    Overrides:
    
    getRole in class org.codehaus.plexus.component.repository.ComponentDescriptor<Mojo>
  - getRoleHint
```
public java.lang.String getRoleHint()
```
    Overrides:
    
    getRoleHint in class org.codehaus.plexus.component.repository.ComponentDescriptor<Mojo>
  - getId
```
public java.lang.String getId()
```
    Returns:
    
    the id of the mojo, based on the goal name
  - getFullGoalName
```
public java.lang.String getFullGoalName()
```
    Returns:
    
    the full goal name
    
    See Also:
    
    PluginDescriptor.getGoalPrefix(), getGoal()
  - getComponentType
```
public java.lang.String getComponentType()
```
    Overrides:
    
    getComponentType in class org.codehaus.plexus.component.repository.ComponentDescriptor<Mojo>
  - getPluginDescriptor
```
public PluginDescriptor getPluginDescriptor()
```
    Returns:
    
    the plugin descriptor
  - setPluginDescriptor
```
public void setPluginDescriptor(PluginDescriptor pluginDescriptor)
```
    Parameters:
    
    pluginDescriptor - the new plugin descriptor
  - isInheritedByDefault
```
public boolean isInheritedByDefault()
```
    Returns:
    
    true if the Mojo is inherited, false otherwise.
  - setInheritedByDefault
```
public void setInheritedByDefault(boolean inheritedByDefault)
```
    Parameters:
    
    inheritedByDefault - true if the Mojo is inherited, false otherwise.
  - equals
```
public boolean equals(java.lang.Object object)
```
    Overrides:
    
    equals in class org.codehaus.plexus.component.repository.ComponentDescriptor<Mojo>
  - compareObjects
```
private boolean compareObjects(java.lang.Object first,
                               java.lang.Object second)
```
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class org.codehaus.plexus.component.repository.ComponentDescriptor<Mojo>
  - getExecuteLifecycle
```
public java.lang.String getExecuteLifecycle()
```
    Returns:
    
    the invocation lifecycle of the Mojo
  - setExecuteLifecycle
```
public void setExecuteLifecycle(java.lang.String executeLifecycle)
```
    Parameters:
    
    executeLifecycle - the new invocation lifecycle of the Mojo
  - setAggregator
```
public void setAggregator(boolean aggregator)
```
    Parameters:
    
    aggregator - true if the Mojo uses the Maven project and its child modules, false otherwise.
  - isAggregator
```
public boolean isAggregator()
```
    Returns:
    
    true if the Mojo uses the Maven project and its child modules, false otherwise.
  - isDirectInvocationOnly
```
public boolean isDirectInvocationOnly()
```
    Returns:
    
    true if the Mojo cannot be invoked directly, false otherwise.
  - setDirectInvocationOnly
```
public void setDirectInvocationOnly(boolean directInvocationOnly)
```
    Parameters:
    
    directInvocationOnly - true if the Mojo cannot be invoked directly, false otherwise.
  - isRequiresReports
```
public boolean isRequiresReports()
```
    Returns:
    
    true if the Mojo needs reports to run, false otherwise.
  - setRequiresReports
```
public void setRequiresReports(boolean requiresReports)
```
    Parameters:
    
    requiresReports - true if the Mojo needs reports to run, false otherwise.
  - setExecuteGoal
```
public void setExecuteGoal(java.lang.String executeGoal)
```
    Parameters:
    
    executeGoal - the new invocation goal of the Mojo
  - getExecuteGoal
```
public java.lang.String getExecuteGoal()
```
    Returns:
    
    the invocation goal of the Mojo
  - isThreadSafe
```
public boolean isThreadSafe()
```
    Returns:
    
    True if the Mojo is thread-safe and can be run safely in parallel
    
    Since:
    
    3.0-beta-2
  - setThreadSafe
```
public void setThreadSafe(boolean threadSafe)
```
    Parameters:
    
    threadSafe - indicates that the mojo is thread-safe and can be run safely in parallel
    
    Since:
    
    3.0-beta-2
  - isForking
```
public boolean isForking()
```
    Returns:
    
    true if this mojo forks either a goal or the lifecycle, false otherwise.
  - clone
```
public MojoDescriptor clone()
```
    Creates a shallow copy of this mojo descriptor.
    
    Overrides:
    
    clone in class java.lang.Object

Class MojoDescriptor

Field Summary

Constructor Summary

Method Summary

Methods inherited from class org.codehaus.plexus.component.repository.ComponentDescriptor

Methods inherited from class java.lang.Object

Field Detail

MAVEN_PLUGIN

SINGLE_PASS_EXEC_STRATEGY

MULTI_PASS_EXEC_STRATEGY

DEFAULT_INSTANTIATION_STRATEGY

DEFAULT_LANGUAGE

parameters

parameterMap

executionStrategy

goal

phase

since

executePhase

executeGoal

executeLifecycle

deprecated

aggregator

dependencyResolutionRequired

dependencyCollectionRequired

projectRequired

onlineRequired

mojoConfiguration

pluginDescriptor

inheritedByDefault

directInvocationOnly

requiresReports

threadSafe

Constructor Detail

MojoDescriptor

Method Detail

getLanguage

setLanguage

getDeprecated

setDeprecated

getParameters

setParameters

addParameter

getParameterMap

setDependencyResolutionRequired

getDependencyResolutionRequired

isDependencyResolutionRequired

setDependencyCollectionRequired

getDependencyCollectionRequired

setProjectRequired

isProjectRequired

setOnlineRequired

isOnlineRequired

requiresOnline

getPhase

setPhase

getSince

setSince

getGoal

setGoal

getExecutePhase

setExecutePhase

alwaysExecute

getExecutionStrategy

setExecutionStrategy

getMojoConfiguration

setMojoConfiguration

getRole

getRoleHint

getId

getFullGoalName

getComponentType

getPluginDescriptor

setPluginDescriptor

isInheritedByDefault

setInheritedByDefault

equals

compareObjects

hashCode

getExecuteLifecycle