001// =================== DO NOT EDIT THIS FILE ==================== 002// Generated by Modello 1.8.1, 003// any modifications will be overwritten. 004// ============================================================== 005 006package org.apache.maven.plugin.descriptor.model; 007 008/** 009 * 010 * A Mojo description. 011 * 012 * 013 * @version $Revision: 879455 $ $Date: 2013-09-22 16:29:47 +0000 (Sun, 22 Sep 2013) $ 014 */ 015@SuppressWarnings( "all" ) 016public 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}