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