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>&lt;phase&gt;</code> element from the
064         *             surrounding <code>&lt;execution&gt;</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>&lt;phase&gt;</code> element from the
428         *             surrounding <code>&lt;execution&gt;</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>&lt;phase&gt;</code> element from the
791         *             surrounding <code>&lt;execution&gt;</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    }