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.model;
007
008 /**
009 *
010 *
011 * The <code><dependency></code> element contains
012 * information about a dependency
013 * of the project.
014 *
015 *
016 *
017 * @version $Revision$ $Date$
018 */
019 @SuppressWarnings( "all" )
020 public class Dependency
021 implements java.io.Serializable, java.lang.Cloneable, org.apache.maven.model.InputLocationTracker
022 {
023
024 //--------------------------/
025 //- Class/Member Variables -/
026 //--------------------------/
027
028 /**
029 *
030 *
031 * The project group that produced the dependency,
032 * e.g.
033 * <code>org.apache.maven</code>.
034 *
035 *
036 */
037 private String groupId;
038
039 /**
040 *
041 *
042 * The unique id for an artifact produced by the
043 * project group, e.g.
044 * <code>maven-artifact</code>.
045 *
046 *
047 */
048 private String artifactId;
049
050 /**
051 *
052 *
053 * The version of the dependency, e.g.
054 * <code>3.2.1</code>. In Maven 2, this can also be
055 * specified as a range of versions.
056 *
057 *
058 */
059 private String version;
060
061 /**
062 *
063 *
064 * The type of dependency. While it
065 * usually represents the extension on the filename
066 * of the dependency,
067 * that is not always the case. A type can be
068 * mapped to a different
069 * extension and a classifier.
070 * The type often corresponds to the packaging
071 * used, though this is also
072 * not always the case.
073 * Some examples are <code>jar</code>,
074 * <code>war</code>, <code>ejb-client</code>
075 * and <code>test-jar</code>: see <a
076 * href="../maven-core/artifact-handlers.html">default
077 * artifact handlers</a> for a list.
078 * New types can be defined by plugins that set
079 * <code>extensions</code> to <code>true</code>, so
080 * this is not a complete list.
081 *
082 *
083 */
084 private String type = "jar";
085
086 /**
087 *
088 *
089 * The classifier of the dependency. It is appended
090 * to
091 * the filename after the version. This allows:
092 * <ul>
093 * <li>refering to attached artifact, for example
094 * <code>sources</code> and <code>javadoc</code>:
095 * see <a
096 * href="../maven-core/artifact-handlers.html">default artifact
097 * handlers</a> for a list,</li>
098 * <li>distinguishing two artifacts
099 * that belong to the same POM but were built
100 * differently.
101 * For example, <code>jdk14</code> and
102 * <code>jdk15</code>.</li>
103 * </ul>
104 *
105 *
106 */
107 private String classifier;
108
109 /**
110 *
111 *
112 * The scope of the dependency -
113 * <code>compile</code>, <code>runtime</code>,
114 * <code>test</code>, <code>system</code>, and
115 * <code>provided</code>. Used to
116 * calculate the various classpaths used for
117 * compilation, testing, and so on.
118 * It also assists in determining which artifacts
119 * to include in a distribution of
120 * this project. For more information, see
121 * <a
122 * href="http://maven.apache.org/guides/introduction/introduction-to-dependency-mechanism.html">the
123 * dependency mechanism</a>.
124 *
125 *
126 */
127 private String scope;
128
129 /**
130 *
131 *
132 * FOR SYSTEM SCOPE ONLY. Note that use of this
133 * property is <b>discouraged</b>
134 * and may be replaced in later versions. This
135 * specifies the path on the filesystem
136 * for this dependency.
137 * Requires an absolute path for the value, not
138 * relative.
139 * Use a property that gives the machine specific
140 * absolute path,
141 * e.g. <code>${java.home}</code>.
142 *
143 *
144 */
145 private String systemPath;
146
147 /**
148 * Field exclusions.
149 */
150 private java.util.List<Exclusion> exclusions;
151
152 /**
153 *
154 *
155 * Indicates the dependency is optional for use of
156 * this library. While the
157 * version of the dependency will be taken into
158 * account for dependency calculation if the
159 * library is used elsewhere, it will not be passed
160 * on transitively. Note: While the type
161 * of this field is <code>String</code> for
162 * technical reasons, the semantic type is actually
163 * <code>Boolean</code>. Default value is
164 * <code>false</code>.
165 *
166 *
167 */
168 private String optional;
169
170 /**
171 * Field locations.
172 */
173 private java.util.Map<Object, InputLocation> locations;
174
175
176 //-----------/
177 //- Methods -/
178 //-----------/
179
180 /**
181 * Method addExclusion.
182 *
183 * @param exclusion
184 */
185 public void addExclusion( Exclusion exclusion )
186 {
187 getExclusions().add( exclusion );
188 } //-- void addExclusion( Exclusion )
189
190 /**
191 * Method clone.
192 *
193 * @return Dependency
194 */
195 public Dependency clone()
196 {
197 try
198 {
199 Dependency copy = (Dependency) super.clone();
200
201 if ( this.exclusions != null )
202 {
203 copy.exclusions = new java.util.ArrayList<Exclusion>();
204 for ( Exclusion item : this.exclusions )
205 {
206 copy.exclusions.add( ( (Exclusion) item).clone() );
207 }
208 }
209
210 if ( copy.locations != null )
211 {
212 copy.locations = new java.util.LinkedHashMap( copy.locations );
213 }
214
215 return copy;
216 }
217 catch ( java.lang.Exception ex )
218 {
219 throw (java.lang.RuntimeException) new java.lang.UnsupportedOperationException( getClass().getName()
220 + " does not support clone()" ).initCause( ex );
221 }
222 } //-- Dependency clone()
223
224 /**
225 * Get the unique id for an artifact produced by the project
226 * group, e.g.
227 * <code>maven-artifact</code>.
228 *
229 * @return String
230 */
231 public String getArtifactId()
232 {
233 return this.artifactId;
234 } //-- String getArtifactId()
235
236 /**
237 * Get the classifier of the dependency. It is appended to
238 * the filename after the version. This allows:
239 * <ul>
240 * <li>refering to attached artifact, for example
241 * <code>sources</code> and <code>javadoc</code>:
242 * see <a
243 * href="../maven-core/artifact-handlers.html">default artifact
244 * handlers</a> for a list,</li>
245 * <li>distinguishing two artifacts
246 * that belong to the same POM but were built
247 * differently.
248 * For example, <code>jdk14</code> and
249 * <code>jdk15</code>.</li>
250 * </ul>
251 *
252 * @return String
253 */
254 public String getClassifier()
255 {
256 return this.classifier;
257 } //-- String getClassifier()
258
259 /**
260 * Method getExclusions.
261 *
262 * @return List
263 */
264 public java.util.List<Exclusion> getExclusions()
265 {
266 if ( this.exclusions == null )
267 {
268 this.exclusions = new java.util.ArrayList<Exclusion>();
269 }
270
271 return this.exclusions;
272 } //-- java.util.List<Exclusion> getExclusions()
273
274 /**
275 * Get the project group that produced the dependency, e.g.
276 * <code>org.apache.maven</code>.
277 *
278 * @return String
279 */
280 public String getGroupId()
281 {
282 return this.groupId;
283 } //-- String getGroupId()
284
285 /**
286 *
287 *
288 * @param key
289 * @return InputLocation
290 */
291 public InputLocation getLocation( Object key )
292 {
293 return ( locations != null ) ? locations.get( key ) : null;
294 } //-- InputLocation getLocation( Object )
295
296 /**
297 * Get indicates the dependency is optional for use of this
298 * library. While the
299 * version of the dependency will be taken into
300 * account for dependency calculation if the
301 * library is used elsewhere, it will not be passed
302 * on transitively. Note: While the type
303 * of this field is <code>String</code> for
304 * technical reasons, the semantic type is actually
305 * <code>Boolean</code>. Default value is
306 * <code>false</code>.
307 *
308 * @return String
309 */
310 public String getOptional()
311 {
312 return this.optional;
313 } //-- String getOptional()
314
315 /**
316 * Get the scope of the dependency - <code>compile</code>,
317 * <code>runtime</code>,
318 * <code>test</code>, <code>system</code>, and
319 * <code>provided</code>. Used to
320 * calculate the various classpaths used for
321 * compilation, testing, and so on.
322 * It also assists in determining which artifacts
323 * to include in a distribution of
324 * this project. For more information, see
325 * <a
326 * href="http://maven.apache.org/guides/introduction/introduction-to-dependency-mechanism.html">the
327 * dependency mechanism</a>.
328 *
329 * @return String
330 */
331 public String getScope()
332 {
333 return this.scope;
334 } //-- String getScope()
335
336 /**
337 * Get fOR SYSTEM SCOPE ONLY. Note that use of this property is
338 * <b>discouraged</b>
339 * and may be replaced in later versions. This
340 * specifies the path on the filesystem
341 * for this dependency.
342 * Requires an absolute path for the value, not
343 * relative.
344 * Use a property that gives the machine specific
345 * absolute path,
346 * e.g. <code>${java.home}</code>.
347 *
348 * @return String
349 */
350 public String getSystemPath()
351 {
352 return this.systemPath;
353 } //-- String getSystemPath()
354
355 /**
356 * Get the type of dependency. While it
357 * usually represents the extension on the filename
358 * of the dependency,
359 * that is not always the case. A type can be
360 * mapped to a different
361 * extension and a classifier.
362 * The type often corresponds to the packaging
363 * used, though this is also
364 * not always the case.
365 * Some examples are <code>jar</code>,
366 * <code>war</code>, <code>ejb-client</code>
367 * and <code>test-jar</code>: see <a
368 * href="../maven-core/artifact-handlers.html">default
369 * artifact handlers</a> for a list.
370 * New types can be defined by plugins that set
371 * <code>extensions</code> to <code>true</code>, so
372 * this is not a complete list.
373 *
374 * @return String
375 */
376 public String getType()
377 {
378 return this.type;
379 } //-- String getType()
380
381 /**
382 * Get the version of the dependency, e.g. <code>3.2.1</code>.
383 * In Maven 2, this can also be
384 * specified as a range of versions.
385 *
386 * @return String
387 */
388 public String getVersion()
389 {
390 return this.version;
391 } //-- String getVersion()
392
393 /**
394 * Method removeExclusion.
395 *
396 * @param exclusion
397 */
398 public void removeExclusion( Exclusion exclusion )
399 {
400 getExclusions().remove( exclusion );
401 } //-- void removeExclusion( Exclusion )
402
403 /**
404 * Set the unique id for an artifact produced by the project
405 * group, e.g.
406 * <code>maven-artifact</code>.
407 *
408 * @param artifactId
409 */
410 public void setArtifactId( String artifactId )
411 {
412 this.artifactId = artifactId;
413 } //-- void setArtifactId( String )
414
415 /**
416 * Set the classifier of the dependency. It is appended to
417 * the filename after the version. This allows:
418 * <ul>
419 * <li>refering to attached artifact, for example
420 * <code>sources</code> and <code>javadoc</code>:
421 * see <a
422 * href="../maven-core/artifact-handlers.html">default artifact
423 * handlers</a> for a list,</li>
424 * <li>distinguishing two artifacts
425 * that belong to the same POM but were built
426 * differently.
427 * For example, <code>jdk14</code> and
428 * <code>jdk15</code>.</li>
429 * </ul>
430 *
431 * @param classifier
432 */
433 public void setClassifier( String classifier )
434 {
435 this.classifier = classifier;
436 } //-- void setClassifier( String )
437
438 /**
439 * Set lists a set of artifacts that should be excluded from
440 * this dependency's
441 * artifact list when it comes to calculating
442 * transitive dependencies.
443 *
444 * @param exclusions
445 */
446 public void setExclusions( java.util.List<Exclusion> exclusions )
447 {
448 this.exclusions = exclusions;
449 } //-- void setExclusions( java.util.List )
450
451 /**
452 * Set the project group that produced the dependency, e.g.
453 * <code>org.apache.maven</code>.
454 *
455 * @param groupId
456 */
457 public void setGroupId( String groupId )
458 {
459 this.groupId = groupId;
460 } //-- void setGroupId( String )
461
462 /**
463 *
464 *
465 * @param key
466 * @param location
467 */
468 public void setLocation( Object key, InputLocation location )
469 {
470 if ( location != null )
471 {
472 if ( this.locations == null )
473 {
474 this.locations = new java.util.LinkedHashMap<Object, InputLocation>();
475 }
476 this.locations.put( key, location );
477 }
478 } //-- void setLocation( Object, InputLocation )
479
480 /**
481 * Set indicates the dependency is optional for use of this
482 * library. While the
483 * version of the dependency will be taken into
484 * account for dependency calculation if the
485 * library is used elsewhere, it will not be passed
486 * on transitively. Note: While the type
487 * of this field is <code>String</code> for
488 * technical reasons, the semantic type is actually
489 * <code>Boolean</code>. Default value is
490 * <code>false</code>.
491 *
492 * @param optional
493 */
494 public void setOptional( String optional )
495 {
496 this.optional = optional;
497 } //-- void setOptional( String )
498
499 /**
500 * Set the scope of the dependency - <code>compile</code>,
501 * <code>runtime</code>,
502 * <code>test</code>, <code>system</code>, and
503 * <code>provided</code>. Used to
504 * calculate the various classpaths used for
505 * compilation, testing, and so on.
506 * It also assists in determining which artifacts
507 * to include in a distribution of
508 * this project. For more information, see
509 * <a
510 * href="http://maven.apache.org/guides/introduction/introduction-to-dependency-mechanism.html">the
511 * dependency mechanism</a>.
512 *
513 * @param scope
514 */
515 public void setScope( String scope )
516 {
517 this.scope = scope;
518 } //-- void setScope( String )
519
520 /**
521 * Set fOR SYSTEM SCOPE ONLY. Note that use of this property is
522 * <b>discouraged</b>
523 * and may be replaced in later versions. This
524 * specifies the path on the filesystem
525 * for this dependency.
526 * Requires an absolute path for the value, not
527 * relative.
528 * Use a property that gives the machine specific
529 * absolute path,
530 * e.g. <code>${java.home}</code>.
531 *
532 * @param systemPath
533 */
534 public void setSystemPath( String systemPath )
535 {
536 this.systemPath = systemPath;
537 } //-- void setSystemPath( String )
538
539 /**
540 * Set the type of dependency. While it
541 * usually represents the extension on the filename
542 * of the dependency,
543 * that is not always the case. A type can be
544 * mapped to a different
545 * extension and a classifier.
546 * The type often corresponds to the packaging
547 * used, though this is also
548 * not always the case.
549 * Some examples are <code>jar</code>,
550 * <code>war</code>, <code>ejb-client</code>
551 * and <code>test-jar</code>: see <a
552 * href="../maven-core/artifact-handlers.html">default
553 * artifact handlers</a> for a list.
554 * New types can be defined by plugins that set
555 * <code>extensions</code> to <code>true</code>, so
556 * this is not a complete list.
557 *
558 * @param type
559 */
560 public void setType( String type )
561 {
562 this.type = type;
563 } //-- void setType( String )
564
565 /**
566 * Set the version of the dependency, e.g. <code>3.2.1</code>.
567 * In Maven 2, this can also be
568 * specified as a range of versions.
569 *
570 * @param version
571 */
572 public void setVersion( String version )
573 {
574 this.version = version;
575 } //-- void setVersion( String )
576
577
578
579 public boolean isOptional()
580 {
581 return ( optional != null ) ? Boolean.parseBoolean( optional ) : false;
582 }
583
584 public void setOptional( boolean optional )
585 {
586 this.optional = String.valueOf( optional );
587 }
588
589 /**
590 * @see java.lang.Object#toString()
591 */
592 public String toString()
593 {
594 return "Dependency {groupId=" + groupId + ", artifactId=" + artifactId + ", version=" + version + ", type=" + type + "}";
595 }
596
597
598
599
600 /**
601 * @return the management key as <code>groupId:artifactId:type</code>
602 */
603 public String getManagementKey()
604 {
605 return groupId + ":" + artifactId + ":" + type + ( classifier != null ? ":" + classifier : "" );
606 }
607
608
609 }