1 /* 2 =================== DO NOT EDIT THIS FILE ==================== 3 Generated by Modello 1.0.1 on 2009-09-09 03:30:24, 4 any modifications will be overwritten. 5 ============================================================== 6 */ 7 8 package org.apache.maven.model; 9 10 /** 11 * 12 * 13 * The <code><dependency></code> element contains 14 * information about a dependency 15 * of the project. 16 * 17 * 18 * 19 * @version $Revision$ $Date$ 20 */ 21 public class Dependency 22 implements java.io.Serializable 23 { 24 25 //--------------------------/ 26 //- Class/Member Variables -/ 27 //--------------------------/ 28 29 /** 30 * 31 * 32 * The project group that produced the dependency, 33 * e.g. 34 * <code>org.apache.maven</code>. 35 * 36 * 37 */ 38 private String groupId; 39 40 /** 41 * 42 * 43 * The unique id for an artifact produced by the 44 * project group, e.g. 45 * <code>maven-artifact</code>. 46 * 47 * 48 */ 49 private String artifactId; 50 51 /** 52 * 53 * 54 * The version of the dependency, e.g. 55 * <code>3.2.1</code>. In Maven 2, this can also be 56 * specified as a range of versions. 57 * 58 * 59 */ 60 private String version; 61 62 /** 63 * 64 * 65 * The type of dependency. This defaults to 66 * <code>jar</code>. While it 67 * usually represents the extension on the filename 68 * of the dependency, 69 * that is not always the case. A type can be 70 * mapped to a different 71 * extension and a classifier. 72 * The type often correspongs to the packaging 73 * used, though this is also 74 * not always the case. 75 * Some examples are <code>jar</code>, 76 * <code>war</code>, <code>ejb-client</code> 77 * and <code>test-jar</code>. 78 * New types can be defined by plugins that set 79 * <code>extensions</code> to <code>true</code>, so 80 * this is not a complete list. 81 * 82 * 83 */ 84 private String type = "jar"; 85 86 /** 87 * 88 * 89 * The classifier of the dependency. This allows 90 * distinguishing two artifacts 91 * that belong to the same POM but were built 92 * differently, and is appended to 93 * the filename after the version. For example, 94 * <code>jdk14</code> and <code>jdk15</code>. 95 * 96 * 97 */ 98 private String classifier; 99 100 /** 101 * 102 * 103 * The scope of the dependency - 104 * <code>compile</code>, <code>runtime</code>, 105 * <code>test</code>, <code>system</code>, and 106 * <code>provided</code>. Used to 107 * calculate the various classpaths used for 108 * compilation, testing, and so on. 109 * It also assists in determining which artifacts 110 * to include in a distribution of 111 * this project. For more information, see 112 * <a 113 * href="http://maven.apache.org/guides/introduction/introduction-to-dependency-mechanism.html">the 114 * dependency mechanism</a>. 115 * 116 * 117 */ 118 private String scope; 119 120 /** 121 * 122 * 123 * FOR SYSTEM SCOPE ONLY. Note that use of this 124 * property is <b>discouraged</b> 125 * and may be replaced in later versions. This 126 * specifies the path on the filesystem 127 * for this dependency. 128 * Requires an absolute path for the value, not 129 * relative. 130 * Use a property that gives the machine specific 131 * absolute path, 132 * e.g. <code>${java.home}</code>. 133 * 134 * 135 */ 136 private String systemPath; 137 138 /** 139 * Field exclusions. 140 */ 141 private java.util.List<Exclusion> exclusions; 142 143 /** 144 * Indicates the dependency is optional for use of this 145 * library. While the 146 * version of the dependency will be taken into 147 * account for dependency calculation if the 148 * library is used elsewhere, it will not be passed 149 * on transitively. 150 */ 151 private boolean optional = false; 152 153 154 //-----------/ 155 //- Methods -/ 156 //-----------/ 157 158 /** 159 * Method addExclusion. 160 * 161 * @param exclusion 162 */ 163 public void addExclusion( Exclusion exclusion ) 164 { 165 if ( !(exclusion instanceof Exclusion) ) 166 { 167 throw new ClassCastException( "Dependency.addExclusions(exclusion) parameter must be instanceof " + Exclusion.class.getName() ); 168 } 169 getExclusions().add( exclusion ); 170 } //-- void addExclusion( Exclusion ) 171 172 /** 173 * Get the unique id for an artifact produced by the project 174 * group, e.g. 175 * <code>maven-artifact</code>. 176 * 177 * @return String 178 */ 179 public String getArtifactId() 180 { 181 return this.artifactId; 182 } //-- String getArtifactId() 183 184 /** 185 * Get the classifier of the dependency. This allows 186 * distinguishing two artifacts 187 * that belong to the same POM but were built 188 * differently, and is appended to 189 * the filename after the version. For example, 190 * <code>jdk14</code> and <code>jdk15</code>. 191 * 192 * @return String 193 */ 194 public String getClassifier() 195 { 196 return this.classifier; 197 } //-- String getClassifier() 198 199 /** 200 * Method getExclusions. 201 * 202 * @return List 203 */ 204 public java.util.List<Exclusion> getExclusions() 205 { 206 if ( this.exclusions == null ) 207 { 208 this.exclusions = new java.util.ArrayList<Exclusion>(); 209 } 210 211 return this.exclusions; 212 } //-- java.util.List<Exclusion> getExclusions() 213 214 /** 215 * Get the project group that produced the dependency, e.g. 216 * <code>org.apache.maven</code>. 217 * 218 * @return String 219 */ 220 public String getGroupId() 221 { 222 return this.groupId; 223 } //-- String getGroupId() 224 225 /** 226 * Get the scope of the dependency - <code>compile</code>, 227 * <code>runtime</code>, 228 * <code>test</code>, <code>system</code>, and 229 * <code>provided</code>. Used to 230 * calculate the various classpaths used for 231 * compilation, testing, and so on. 232 * It also assists in determining which artifacts 233 * to include in a distribution of 234 * this project. For more information, see 235 * <a 236 * href="http://maven.apache.org/guides/introduction/introduction-to-dependency-mechanism.html">the 237 * dependency mechanism</a>. 238 * 239 * @return String 240 */ 241 public String getScope() 242 { 243 return this.scope; 244 } //-- String getScope() 245 246 /** 247 * Get fOR SYSTEM SCOPE ONLY. Note that use of this property is 248 * <b>discouraged</b> 249 * and may be replaced in later versions. This 250 * specifies the path on the filesystem 251 * for this dependency. 252 * Requires an absolute path for the value, not 253 * relative. 254 * Use a property that gives the machine specific 255 * absolute path, 256 * e.g. <code>${java.home}</code>. 257 * 258 * @return String 259 */ 260 public String getSystemPath() 261 { 262 return this.systemPath; 263 } //-- String getSystemPath() 264 265 /** 266 * Get the type of dependency. This defaults to 267 * <code>jar</code>. While it 268 * usually represents the extension on the filename 269 * of the dependency, 270 * that is not always the case. A type can be 271 * mapped to a different 272 * extension and a classifier. 273 * The type often correspongs to the packaging 274 * used, though this is also 275 * not always the case. 276 * Some examples are <code>jar</code>, 277 * <code>war</code>, <code>ejb-client</code> 278 * and <code>test-jar</code>. 279 * New types can be defined by plugins that set 280 * <code>extensions</code> to <code>true</code>, so 281 * this is not a complete list. 282 * 283 * @return String 284 */ 285 public String getType() 286 { 287 return this.type; 288 } //-- String getType() 289 290 /** 291 * Get the version of the dependency, e.g. <code>3.2.1</code>. 292 * In Maven 2, this can also be 293 * specified as a range of versions. 294 * 295 * @return String 296 */ 297 public String getVersion() 298 { 299 return this.version; 300 } //-- String getVersion() 301 302 /** 303 * Get indicates the dependency is optional for use of this 304 * library. While the 305 * version of the dependency will be taken into 306 * account for dependency calculation if the 307 * library is used elsewhere, it will not be passed 308 * on transitively. 309 * 310 * @return boolean 311 */ 312 public boolean isOptional() 313 { 314 return this.optional; 315 } //-- boolean isOptional() 316 317 /** 318 * Method removeExclusion. 319 * 320 * @param exclusion 321 */ 322 public void removeExclusion( Exclusion exclusion ) 323 { 324 if ( !(exclusion instanceof Exclusion) ) 325 { 326 throw new ClassCastException( "Dependency.removeExclusions(exclusion) parameter must be instanceof " + Exclusion.class.getName() ); 327 } 328 getExclusions().remove( exclusion ); 329 } //-- void removeExclusion( Exclusion ) 330 331 /** 332 * Set the unique id for an artifact produced by the project 333 * group, e.g. 334 * <code>maven-artifact</code>. 335 * 336 * @param artifactId 337 */ 338 public void setArtifactId( String artifactId ) 339 { 340 this.artifactId = artifactId; 341 } //-- void setArtifactId( String ) 342 343 /** 344 * Set the classifier of the dependency. This allows 345 * distinguishing two artifacts 346 * that belong to the same POM but were built 347 * differently, and is appended to 348 * the filename after the version. For example, 349 * <code>jdk14</code> and <code>jdk15</code>. 350 * 351 * @param classifier 352 */ 353 public void setClassifier( String classifier ) 354 { 355 this.classifier = classifier; 356 } //-- void setClassifier( String ) 357 358 /** 359 * Set lists a set of artifacts that should be excluded from 360 * this dependency's 361 * artifact list when it comes to calculating 362 * transitive dependencies. 363 * 364 * @param exclusions 365 */ 366 public void setExclusions( java.util.List<Exclusion> exclusions ) 367 { 368 this.exclusions = exclusions; 369 } //-- void setExclusions( java.util.List ) 370 371 /** 372 * Set the project group that produced the dependency, e.g. 373 * <code>org.apache.maven</code>. 374 * 375 * @param groupId 376 */ 377 public void setGroupId( String groupId ) 378 { 379 this.groupId = groupId; 380 } //-- void setGroupId( String ) 381 382 /** 383 * Set indicates the dependency is optional for use of this 384 * library. While the 385 * version of the dependency will be taken into 386 * account for dependency calculation if the 387 * library is used elsewhere, it will not be passed 388 * on transitively. 389 * 390 * @param optional 391 */ 392 public void setOptional( boolean optional ) 393 { 394 this.optional = optional; 395 } //-- void setOptional( boolean ) 396 397 /** 398 * Set the scope of the dependency - <code>compile</code>, 399 * <code>runtime</code>, 400 * <code>test</code>, <code>system</code>, and 401 * <code>provided</code>. Used to 402 * calculate the various classpaths used for 403 * compilation, testing, and so on. 404 * It also assists in determining which artifacts 405 * to include in a distribution of 406 * this project. For more information, see 407 * <a 408 * href="http://maven.apache.org/guides/introduction/introduction-to-dependency-mechanism.html">the 409 * dependency mechanism</a>. 410 * 411 * @param scope 412 */ 413 public void setScope( String scope ) 414 { 415 this.scope = scope; 416 } //-- void setScope( String ) 417 418 /** 419 * Set fOR SYSTEM SCOPE ONLY. Note that use of this property is 420 * <b>discouraged</b> 421 * and may be replaced in later versions. This 422 * specifies the path on the filesystem 423 * for this dependency. 424 * Requires an absolute path for the value, not 425 * relative. 426 * Use a property that gives the machine specific 427 * absolute path, 428 * e.g. <code>${java.home}</code>. 429 * 430 * @param systemPath 431 */ 432 public void setSystemPath( String systemPath ) 433 { 434 this.systemPath = systemPath; 435 } //-- void setSystemPath( String ) 436 437 /** 438 * Set the type of dependency. This defaults to 439 * <code>jar</code>. While it 440 * usually represents the extension on the filename 441 * of the dependency, 442 * that is not always the case. A type can be 443 * mapped to a different 444 * extension and a classifier. 445 * The type often correspongs to the packaging 446 * used, though this is also 447 * not always the case. 448 * Some examples are <code>jar</code>, 449 * <code>war</code>, <code>ejb-client</code> 450 * and <code>test-jar</code>. 451 * New types can be defined by plugins that set 452 * <code>extensions</code> to <code>true</code>, so 453 * this is not a complete list. 454 * 455 * @param type 456 */ 457 public void setType( String type ) 458 { 459 this.type = type; 460 } //-- void setType( String ) 461 462 /** 463 * Set the version of the dependency, e.g. <code>3.2.1</code>. 464 * In Maven 2, this can also be 465 * specified as a range of versions. 466 * 467 * @param version 468 */ 469 public void setVersion( String version ) 470 { 471 this.version = version; 472 } //-- void setVersion( String ) 473 474 475 476 /** 477 * @see java.lang.Object#toString() 478 */ 479 public String toString() 480 { 481 return "Dependency {groupId=" + groupId + ", artifactId=" + artifactId + ", version=" + version + ", type=" + type + "}"; 482 } 483 484 485 486 /** 487 * @return the management key as <code>groupId:artifactId:type</code> 488 */ 489 public String getManagementKey() 490 { 491 return groupId + ":" + artifactId + ":" + type + ( classifier != null ? ":" + classifier : "" ); 492 } 493 494 495 }