001 // =================== DO NOT EDIT THIS FILE ====================
002 // Generated by Modello 1.7,
003 // any modifications will be overwritten.
004 // ==============================================================
005
006 package org.apache.maven.plugin.descriptor.model;
007
008 /**
009 *
010 * A Mojo description.
011 *
012 *
013 * @version $Revision: 855142 $ $Date: 2013-03-20 00:55:13 +0000 (Wed, 20 Mar 2013) $
014 */
015 @SuppressWarnings( "all" )
016 public class MojoDescriptor
017 implements java.io.Serializable
018 {
019
020 //--------------------------/
021 //- Class/Member Variables -/
022 //--------------------------/
023
024 /**
025 *
026 * The goal name for the Mojo, that users will
027 * reference from the command line to execute the Mojo
028 * directly,
029 * or inside a POM in order to provide
030 * Mojo-specific configuration.
031 *
032 */
033 private String goal;
034
035 /**
036 * The description of this Mojo's functionality.
037 */
038 private String description;
039
040 /**
041 *
042 * The Mojo's fully-qualified class name (or script
043 * path in the case of non-Java Mojos).
044 *
045 */
046 private String implementation;
047
048 /**
049 * The implementation language for this Mojo (java, beanshell,
050 * etc.).
051 */
052 private String language = "java";
053
054 /**
055 *
056 * Defines a default phase to bind a mojo execution
057 * to if the user does not explicitly set a phase in the POM.
058 * <i>Note:</i> This will not automagically make a
059 * mojo run when the plugin declaration is added
060 * to the POM. It merely enables the user to omit
061 * the <code><phase></code> element from the
062 * surrounding <code><execution></code>
063 * element.
064 *
065 */
066 private String phase;
067
068 /**
069 * Reference the invocation phase of the Mojo.
070 */
071 private String executePhase;
072
073 /**
074 * Reference the invocation goal of the Mojo.
075 */
076 private String executeGoal;
077
078 /**
079 * Field executeLifecycle.
080 */
081 private String executeLifecycle;
082
083 /**
084 *
085 * Flags this Mojo as requiring the dependencies in
086 * the specified class path to be resolved before it can
087 * execute: <code>compile</code>,
088 * <code>runtime</code>, <code>test</code>,
089 * <code>compile+runtime</code> (since Maven 3.0)
090 * or <code>runtime+system</code> (since Maven 3.0)
091 * .
092 */
093 private String requiresDependencyResolution = "runtime";
094
095 /**
096 *
097 * Flags this mojo as requiring information about
098 * the dependencies that would make up the specified class
099 * 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><phase></code> element from the
426 * surrounding <code><execution></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><phase></code> element from the
789 * surrounding <code><execution></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 }