View Javadoc

1   // =================== DO NOT EDIT THIS FILE ====================
2   // Generated by Modello 1.7,
3   // any modifications will be overwritten.
4   // ==============================================================
5   
6   package org.apache.maven.plugin.descriptor.model;
7   
8   /**
9    * 
10   *         A Mojo description.
11   *       
12   * 
13   * @version $Revision: 855142 $ $Date: 2013-03-20 01:55:13 +0100 (Wed, 20 Mar 2013) $
14   */
15  @SuppressWarnings( "all" )
16  public class MojoDescriptor
17      implements java.io.Serializable
18  {
19  
20        //--------------------------/
21       //- Class/Member Variables -/
22      //--------------------------/
23  
24      /**
25       * 
26       *             The goal name for the Mojo, that users will
27       * reference from the command line to execute the Mojo
28       * directly,
29       *             or inside a POM in order to provide
30       * Mojo-specific configuration.
31       *           
32       */
33      private String goal;
34  
35      /**
36       * The description of this Mojo's functionality.
37       */
38      private String description;
39  
40      /**
41       * 
42       *             The Mojo's fully-qualified class name (or script
43       * path in the case of non-Java Mojos).
44       *           
45       */
46      private String implementation;
47  
48      /**
49       * The implementation language for this Mojo (java, beanshell,
50       * etc.).
51       */
52      private String language = "java";
53  
54      /**
55       * 
56       *             Defines a default phase to bind a mojo execution
57       * to if the user does not explicitly set a phase in the POM.
58       *             <i>Note:</i> This will not automagically make a
59       * mojo run when the plugin declaration is added
60       *             to the POM. It merely enables the user to omit
61       * the <code>&lt;phase&gt;</code> element from the
62       *             surrounding <code>&lt;execution&gt;</code>
63       * element.
64       *           
65       */
66      private String phase;
67  
68      /**
69       * Reference the invocation phase of the Mojo.
70       */
71      private String executePhase;
72  
73      /**
74       * Reference the invocation goal of the Mojo.
75       */
76      private String executeGoal;
77  
78      /**
79       * Field executeLifecycle.
80       */
81      private String executeLifecycle;
82  
83      /**
84       * 
85       *             Flags this Mojo as requiring the dependencies in
86       * the specified class path to be resolved before it can
87       *             execute: <code>compile</code>,
88       * <code>runtime</code>, <code>test</code>,
89       *             <code>compile+runtime</code> (since Maven 3.0)
90       * or <code>runtime+system</code> (since Maven 3.0)
91       *           .
92       */
93      private String requiresDependencyResolution = "runtime";
94  
95      /**
96       * 
97       *             Flags this mojo as requiring information about
98       * the dependencies that would make up the specified class
99       *             path. As the name suggests, this is similar to
100      * requiresDependencyResolution and supports the same values.
101      *             The important difference is this will not
102      * resolve the files for the dependencies, i.e. the artifacts
103      *             associated with a Maven project can lack a file.
104      * As such, this annotation is meant for mojos that only
105      *             want to analyze the set of transitive
106      * dependencies, in particular during early lifecycle phases
107      * where
108      *             full dependency resolution might fail due to
109      * projects which haven't been built yet.
110      *           
111      */
112     private String requiresDependencyCollection;
113 
114     /**
115      * Flags this Mojo to be invoked directly only.
116      */
117     private boolean requiresDirectInvocation = false;
118 
119     /**
120      * Flags this Mojo to require running inside of a project.
121      */
122     private boolean requiresProject = true;
123 
124     /**
125      * Flags this Mojo to require running inside of a reports
126      * context. Unsupported since Maven 3.0.
127      */
128     private boolean requiresReports = false;
129 
130     /**
131      * Flags this Mojo to require online mode for its operation.
132      */
133     private boolean requiresOnline = false;
134 
135     /**
136      * 
137      *             Flags this Mojo to run it in a multi module way,
138      * i.e. aggregate the build with the set of projects
139      *             listed as modules.
140      *           
141      */
142     private boolean aggregator = false;
143 
144     /**
145      * Specify that the Mojo is inherited.
146      */
147     private boolean inheritedByDefault = true;
148 
149     /**
150      * 
151      *             Marks this mojo as being thread-safe, i.e. the
152      * mojo safely supports concurrent execution during parallel
153      *             builds. Mojos without this annotation will make
154      * Maven output a warning when used during a parallel build
155      *             session. Since Maven 3.0.
156      *           
157      */
158     private boolean threadSafe = false;
159 
160     /**
161      * Specify the instantiation strategy.
162      */
163     private String instantiationStrategy = "per-lookup";
164 
165     /**
166      * 
167      *             Specify the execution strategy:
168      * <code>once-per-session</code>, <code>always</code>.
169      *           
170      */
171     private String executionStrategy = "once-per-session";
172 
173     /**
174      * Specify the version when the Mojo was added to the API.
175      * Similar to Javadoc since.
176      */
177     private String since;
178 
179     /**
180      * 
181      *             Specify the version when the Mojo was deprecated
182      * to the API. Similar to Javadoc deprecated. This will
183      *             trigger a warning when a user tries to configure
184      * a parameter marked as deprecated.
185      *           
186      */
187     private String deprecated;
188 
189     /**
190      * 
191      *             The configurator type to use when injecting
192      * parameter values into this Mojo. The value is normally
193      * deduced
194      *             from the Mojo's implementation language, but can
195      * be specified to allow a custom ComponentConfigurator
196      *             implementation to be used.
197      *           
198      */
199     private String configurator;
200 
201     /**
202      * Field composer.
203      */
204     private String composer;
205 
206     /**
207      * Field parameters.
208      */
209     private java.util.List<Parameter> parameters;
210 
211     /**
212      * Field configuration.
213      */
214     private java.util.List<Configuration> configuration;
215 
216     /**
217      * Field requirements.
218      */
219     private java.util.List<Requirement> requirements;
220 
221 
222       //-----------/
223      //- Methods -/
224     //-----------/
225 
226     /**
227      * Method addConfiguration.
228      * 
229      * @param configuration
230      */
231     public void addConfiguration( Configuration configuration )
232     {
233         getConfiguration().add( configuration );
234     } //-- void addConfiguration( Configuration )
235 
236     /**
237      * Method addParameter.
238      * 
239      * @param parameter
240      */
241     public void addParameter( Parameter parameter )
242     {
243         getParameters().add( parameter );
244     } //-- void addParameter( Parameter )
245 
246     /**
247      * Method addRequirement.
248      * 
249      * @param requirement
250      */
251     public void addRequirement( Requirement requirement )
252     {
253         getRequirements().add( requirement );
254     } //-- void addRequirement( Requirement )
255 
256     /**
257      * Get the composer field.
258      * 
259      * @return String
260      */
261     public String getComposer()
262     {
263         return this.composer;
264     } //-- String getComposer()
265 
266     /**
267      * Method getConfiguration.
268      * 
269      * @return List
270      */
271     public java.util.List<Configuration> getConfiguration()
272     {
273         if ( this.configuration == null )
274         {
275             this.configuration = new java.util.ArrayList<Configuration>();
276         }
277 
278         return this.configuration;
279     } //-- java.util.List<Configuration> getConfiguration()
280 
281     /**
282      * Get the configurator type to use when injecting parameter
283      * values into this Mojo. The value is normally deduced
284      *             from the Mojo's implementation language, but can
285      * be specified to allow a custom ComponentConfigurator
286      *             implementation to be used.
287      * 
288      * @return String
289      */
290     public String getConfigurator()
291     {
292         return this.configurator;
293     } //-- String getConfigurator()
294 
295     /**
296      * Get specify the version when the Mojo was deprecated to the
297      * API. Similar to Javadoc deprecated. This will
298      *             trigger a warning when a user tries to configure
299      * a parameter marked as deprecated.
300      * 
301      * @return String
302      */
303     public String getDeprecated()
304     {
305         return this.deprecated;
306     } //-- String getDeprecated()
307 
308     /**
309      * Get the description of this Mojo's functionality.
310      * 
311      * @return String
312      */
313     public String getDescription()
314     {
315         return this.description;
316     } //-- String getDescription()
317 
318     /**
319      * Get reference the invocation goal of the Mojo.
320      * 
321      * @return String
322      */
323     public String getExecuteGoal()
324     {
325         return this.executeGoal;
326     } //-- String getExecuteGoal()
327 
328     /**
329      * Get the executeLifecycle field.
330      * 
331      * @return String
332      */
333     public String getExecuteLifecycle()
334     {
335         return this.executeLifecycle;
336     } //-- String getExecuteLifecycle()
337 
338     /**
339      * Get reference the invocation phase of the Mojo.
340      * 
341      * @return String
342      */
343     public String getExecutePhase()
344     {
345         return this.executePhase;
346     } //-- String getExecutePhase()
347 
348     /**
349      * Get specify the execution strategy:
350      * <code>once-per-session</code>, <code>always</code>.
351      * 
352      * @return String
353      */
354     public String getExecutionStrategy()
355     {
356         return this.executionStrategy;
357     } //-- String getExecutionStrategy()
358 
359     /**
360      * Get the goal name for the Mojo, that users will reference
361      * from the command line to execute the Mojo directly,
362      *             or inside a POM in order to provide
363      * Mojo-specific configuration.
364      * 
365      * @return String
366      */
367     public String getGoal()
368     {
369         return this.goal;
370     } //-- String getGoal()
371 
372     /**
373      * Get the Mojo's fully-qualified class name (or script path in
374      * the case of non-Java Mojos).
375      * 
376      * @return String
377      */
378     public String getImplementation()
379     {
380         return this.implementation;
381     } //-- String getImplementation()
382 
383     /**
384      * Get specify the instantiation strategy.
385      * 
386      * @return String
387      */
388     public String getInstantiationStrategy()
389     {
390         return this.instantiationStrategy;
391     } //-- String getInstantiationStrategy()
392 
393     /**
394      * Get the implementation language for this Mojo (java,
395      * beanshell, etc.).
396      * 
397      * @return String
398      */
399     public String getLanguage()
400     {
401         return this.language;
402     } //-- String getLanguage()
403 
404     /**
405      * Method getParameters.
406      * 
407      * @return List
408      */
409     public java.util.List<Parameter> getParameters()
410     {
411         if ( this.parameters == null )
412         {
413             this.parameters = new java.util.ArrayList<Parameter>();
414         }
415 
416         return this.parameters;
417     } //-- java.util.List<Parameter> getParameters()
418 
419     /**
420      * Get defines a default phase to bind a mojo execution to if
421      * the user does not explicitly set a phase in the POM.
422      *             <i>Note:</i> This will not automagically make a
423      * mojo run when the plugin declaration is added
424      *             to the POM. It merely enables the user to omit
425      * the <code>&lt;phase&gt;</code> element from the
426      *             surrounding <code>&lt;execution&gt;</code>
427      * element.
428      * 
429      * @return String
430      */
431     public String getPhase()
432     {
433         return this.phase;
434     } //-- String getPhase()
435 
436     /**
437      * Method getRequirements.
438      * 
439      * @return List
440      */
441     public java.util.List<Requirement> getRequirements()
442     {
443         if ( this.requirements == null )
444         {
445             this.requirements = new java.util.ArrayList<Requirement>();
446         }
447 
448         return this.requirements;
449     } //-- java.util.List<Requirement> getRequirements()
450 
451     /**
452      * Get flags this mojo as requiring information about the
453      * dependencies that would make up the specified class
454      *             path. As the name suggests, this is similar to
455      * requiresDependencyResolution and supports the same values.
456      *             The important difference is this will not
457      * resolve the files for the dependencies, i.e. the artifacts
458      *             associated with a Maven project can lack a file.
459      * As such, this annotation is meant for mojos that only
460      *             want to analyze the set of transitive
461      * dependencies, in particular during early lifecycle phases
462      * where
463      *             full dependency resolution might fail due to
464      * projects which haven't been built yet.
465      * 
466      * @return String
467      */
468     public String getRequiresDependencyCollection()
469     {
470         return this.requiresDependencyCollection;
471     } //-- String getRequiresDependencyCollection()
472 
473     /**
474      * Get flags this Mojo as requiring the dependencies in the
475      * specified class path to be resolved before it can
476      *             execute: <code>compile</code>,
477      * <code>runtime</code>, <code>test</code>,
478      *             <code>compile+runtime</code> (since Maven 3.0)
479      * or <code>runtime+system</code> (since Maven 3.0).
480      * 
481      * @return String
482      */
483     public String getRequiresDependencyResolution()
484     {
485         return this.requiresDependencyResolution;
486     } //-- String getRequiresDependencyResolution()
487 
488     /**
489      * Get specify the version when the Mojo was added to the API.
490      * Similar to Javadoc since.
491      * 
492      * @return String
493      */
494     public String getSince()
495     {
496         return this.since;
497     } //-- String getSince()
498 
499     /**
500      * Get flags this Mojo to run it in a multi module way, i.e.
501      * aggregate the build with the set of projects
502      *             listed as modules.
503      * 
504      * @return boolean
505      */
506     public boolean isAggregator()
507     {
508         return this.aggregator;
509     } //-- boolean isAggregator()
510 
511     /**
512      * Get specify that the Mojo is inherited.
513      * 
514      * @return boolean
515      */
516     public boolean isInheritedByDefault()
517     {
518         return this.inheritedByDefault;
519     } //-- boolean isInheritedByDefault()
520 
521     /**
522      * Get flags this Mojo to be invoked directly only.
523      * 
524      * @return boolean
525      */
526     public boolean isRequiresDirectInvocation()
527     {
528         return this.requiresDirectInvocation;
529     } //-- boolean isRequiresDirectInvocation()
530 
531     /**
532      * Get flags this Mojo to require online mode for its
533      * operation.
534      * 
535      * @return boolean
536      */
537     public boolean isRequiresOnline()
538     {
539         return this.requiresOnline;
540     } //-- boolean isRequiresOnline()
541 
542     /**
543      * Get flags this Mojo to require running inside of a project.
544      * 
545      * @return boolean
546      */
547     public boolean isRequiresProject()
548     {
549         return this.requiresProject;
550     } //-- boolean isRequiresProject()
551 
552     /**
553      * Get flags this Mojo to require running inside of a reports
554      * context. Unsupported since Maven 3.0.
555      * 
556      * @return boolean
557      */
558     public boolean isRequiresReports()
559     {
560         return this.requiresReports;
561     } //-- boolean isRequiresReports()
562 
563     /**
564      * Get marks this mojo as being thread-safe, i.e. the mojo
565      * safely supports concurrent execution during parallel
566      *             builds. Mojos without this annotation will make
567      * Maven output a warning when used during a parallel build
568      *             session. Since Maven 3.0.
569      * 
570      * @return boolean
571      */
572     public boolean isThreadSafe()
573     {
574         return this.threadSafe;
575     } //-- boolean isThreadSafe()
576 
577     /**
578      * Method removeConfiguration.
579      * 
580      * @param configuration
581      */
582     public void removeConfiguration( Configuration configuration )
583     {
584         getConfiguration().remove( configuration );
585     } //-- void removeConfiguration( Configuration )
586 
587     /**
588      * Method removeParameter.
589      * 
590      * @param parameter
591      */
592     public void removeParameter( Parameter parameter )
593     {
594         getParameters().remove( parameter );
595     } //-- void removeParameter( Parameter )
596 
597     /**
598      * Method removeRequirement.
599      * 
600      * @param requirement
601      */
602     public void removeRequirement( Requirement requirement )
603     {
604         getRequirements().remove( requirement );
605     } //-- void removeRequirement( Requirement )
606 
607     /**
608      * Set flags this Mojo to run it in a multi module way, i.e.
609      * aggregate the build with the set of projects
610      *             listed as modules.
611      * 
612      * @param aggregator
613      */
614     public void setAggregator( boolean aggregator )
615     {
616         this.aggregator = aggregator;
617     } //-- void setAggregator( boolean )
618 
619     /**
620      * Set the composer field.
621      * 
622      * @param composer
623      */
624     public void setComposer( String composer )
625     {
626         this.composer = composer;
627     } //-- void setComposer( String )
628 
629     /**
630      * Set the configuration field.
631      * 
632      * @param configuration
633      */
634     public void setConfiguration( java.util.List<Configuration> configuration )
635     {
636         this.configuration = configuration;
637     } //-- void setConfiguration( java.util.List )
638 
639     /**
640      * Set the configurator type to use when injecting parameter
641      * values into this Mojo. The value is normally deduced
642      *             from the Mojo's implementation language, but can
643      * be specified to allow a custom ComponentConfigurator
644      *             implementation to be used.
645      * 
646      * @param configurator
647      */
648     public void setConfigurator( String configurator )
649     {
650         this.configurator = configurator;
651     } //-- void setConfigurator( String )
652 
653     /**
654      * Set specify the version when the Mojo was deprecated to the
655      * API. Similar to Javadoc deprecated. This will
656      *             trigger a warning when a user tries to configure
657      * a parameter marked as deprecated.
658      * 
659      * @param deprecated
660      */
661     public void setDeprecated( String deprecated )
662     {
663         this.deprecated = deprecated;
664     } //-- void setDeprecated( String )
665 
666     /**
667      * Set the description of this Mojo's functionality.
668      * 
669      * @param description
670      */
671     public void setDescription( String description )
672     {
673         this.description = description;
674     } //-- void setDescription( String )
675 
676     /**
677      * Set reference the invocation goal of the Mojo.
678      * 
679      * @param executeGoal
680      */
681     public void setExecuteGoal( String executeGoal )
682     {
683         this.executeGoal = executeGoal;
684     } //-- void setExecuteGoal( String )
685 
686     /**
687      * Set the executeLifecycle field.
688      * 
689      * @param executeLifecycle
690      */
691     public void setExecuteLifecycle( String executeLifecycle )
692     {
693         this.executeLifecycle = executeLifecycle;
694     } //-- void setExecuteLifecycle( String )
695 
696     /**
697      * Set reference the invocation phase of the Mojo.
698      * 
699      * @param executePhase
700      */
701     public void setExecutePhase( String executePhase )
702     {
703         this.executePhase = executePhase;
704     } //-- void setExecutePhase( String )
705 
706     /**
707      * Set specify the execution strategy:
708      * <code>once-per-session</code>, <code>always</code>.
709      * 
710      * @param executionStrategy
711      */
712     public void setExecutionStrategy( String executionStrategy )
713     {
714         this.executionStrategy = executionStrategy;
715     } //-- void setExecutionStrategy( String )
716 
717     /**
718      * Set the goal name for the Mojo, that users will reference
719      * from the command line to execute the Mojo directly,
720      *             or inside a POM in order to provide
721      * Mojo-specific configuration.
722      * 
723      * @param goal
724      */
725     public void setGoal( String goal )
726     {
727         this.goal = goal;
728     } //-- void setGoal( String )
729 
730     /**
731      * Set the Mojo's fully-qualified class name (or script path in
732      * the case of non-Java Mojos).
733      * 
734      * @param implementation
735      */
736     public void setImplementation( String implementation )
737     {
738         this.implementation = implementation;
739     } //-- void setImplementation( String )
740 
741     /**
742      * Set specify that the Mojo is inherited.
743      * 
744      * @param inheritedByDefault
745      */
746     public void setInheritedByDefault( boolean inheritedByDefault )
747     {
748         this.inheritedByDefault = inheritedByDefault;
749     } //-- void setInheritedByDefault( boolean )
750 
751     /**
752      * Set specify the instantiation strategy.
753      * 
754      * @param instantiationStrategy
755      */
756     public void setInstantiationStrategy( String instantiationStrategy )
757     {
758         this.instantiationStrategy = instantiationStrategy;
759     } //-- void setInstantiationStrategy( String )
760 
761     /**
762      * Set the implementation language for this Mojo (java,
763      * beanshell, etc.).
764      * 
765      * @param language
766      */
767     public void setLanguage( String language )
768     {
769         this.language = language;
770     } //-- void setLanguage( String )
771 
772     /**
773      * Set the parameters field.
774      * 
775      * @param parameters
776      */
777     public void setParameters( java.util.List<Parameter> parameters )
778     {
779         this.parameters = parameters;
780     } //-- void setParameters( java.util.List )
781 
782     /**
783      * Set defines a default phase to bind a mojo execution to if
784      * the user does not explicitly set a phase in the POM.
785      *             <i>Note:</i> This will not automagically make a
786      * mojo run when the plugin declaration is added
787      *             to the POM. It merely enables the user to omit
788      * the <code>&lt;phase&gt;</code> element from the
789      *             surrounding <code>&lt;execution&gt;</code>
790      * element.
791      * 
792      * @param phase
793      */
794     public void setPhase( String phase )
795     {
796         this.phase = phase;
797     } //-- void setPhase( String )
798 
799     /**
800      * Set the requirements field.
801      * 
802      * @param requirements
803      */
804     public void setRequirements( java.util.List<Requirement> requirements )
805     {
806         this.requirements = requirements;
807     } //-- void setRequirements( java.util.List )
808 
809     /**
810      * Set flags this mojo as requiring information about the
811      * dependencies that would make up the specified class
812      *             path. As the name suggests, this is similar to
813      * requiresDependencyResolution and supports the same values.
814      *             The important difference is this will not
815      * resolve the files for the dependencies, i.e. the artifacts
816      *             associated with a Maven project can lack a file.
817      * As such, this annotation is meant for mojos that only
818      *             want to analyze the set of transitive
819      * dependencies, in particular during early lifecycle phases
820      * where
821      *             full dependency resolution might fail due to
822      * projects which haven't been built yet.
823      * 
824      * @param requiresDependencyCollection
825      */
826     public void setRequiresDependencyCollection( String requiresDependencyCollection )
827     {
828         this.requiresDependencyCollection = requiresDependencyCollection;
829     } //-- void setRequiresDependencyCollection( String )
830 
831     /**
832      * Set flags this Mojo as requiring the dependencies in the
833      * specified class path to be resolved before it can
834      *             execute: <code>compile</code>,
835      * <code>runtime</code>, <code>test</code>,
836      *             <code>compile+runtime</code> (since Maven 3.0)
837      * or <code>runtime+system</code> (since Maven 3.0).
838      * 
839      * @param requiresDependencyResolution
840      */
841     public void setRequiresDependencyResolution( String requiresDependencyResolution )
842     {
843         this.requiresDependencyResolution = requiresDependencyResolution;
844     } //-- void setRequiresDependencyResolution( String )
845 
846     /**
847      * Set flags this Mojo to be invoked directly only.
848      * 
849      * @param requiresDirectInvocation
850      */
851     public void setRequiresDirectInvocation( boolean requiresDirectInvocation )
852     {
853         this.requiresDirectInvocation = requiresDirectInvocation;
854     } //-- void setRequiresDirectInvocation( boolean )
855 
856     /**
857      * Set flags this Mojo to require online mode for its
858      * operation.
859      * 
860      * @param requiresOnline
861      */
862     public void setRequiresOnline( boolean requiresOnline )
863     {
864         this.requiresOnline = requiresOnline;
865     } //-- void setRequiresOnline( boolean )
866 
867     /**
868      * Set flags this Mojo to require running inside of a project.
869      * 
870      * @param requiresProject
871      */
872     public void setRequiresProject( boolean requiresProject )
873     {
874         this.requiresProject = requiresProject;
875     } //-- void setRequiresProject( boolean )
876 
877     /**
878      * Set flags this Mojo to require running inside of a reports
879      * context. Unsupported since Maven 3.0.
880      * 
881      * @param requiresReports
882      */
883     public void setRequiresReports( boolean requiresReports )
884     {
885         this.requiresReports = requiresReports;
886     } //-- void setRequiresReports( boolean )
887 
888     /**
889      * Set specify the version when the Mojo was added to the API.
890      * Similar to Javadoc since.
891      * 
892      * @param since
893      */
894     public void setSince( String since )
895     {
896         this.since = since;
897     } //-- void setSince( String )
898 
899     /**
900      * Set marks this mojo as being thread-safe, i.e. the mojo
901      * safely supports concurrent execution during parallel
902      *             builds. Mojos without this annotation will make
903      * Maven output a warning when used during a parallel build
904      *             session. Since Maven 3.0.
905      * 
906      * @param threadSafe
907      */
908     public void setThreadSafe( boolean threadSafe )
909     {
910         this.threadSafe = threadSafe;
911     } //-- void setThreadSafe( boolean )
912 
913 }