Coverage Report

Coverage Report - org.apache.maven.model.Dependency

Classes in this File

Line Coverage

Branch Coverage

Complexity

Dependency

0/46

0/12

1.208

 /*
  * $Id$
  */
 
 package org.apache.maven.model;
 
   //---------------------------------/
  //- Imported classes and packages -/
 //---------------------------------/
 
 import java.util.Date;
 
 /**
  * 
  *         
  *         The <code>&lt;dependency&gt;</code> element contains
  * information about a dependency
  *         of the project.
  *         
  *       
  * 
  * @version $Revision$ $Date$
  */
 public class Dependency implements java.io.Serializable {
 
 
       //--------------------------/
      //- Class/Member Variables -/
     //--------------------------/
 
     /**
      * 
      *             
      *             The project group that produced the dependency,
      * e.g.
      *             <code>org.apache.maven</code>.
      *             
      *           
      */
     private String groupId;
 
     /**
      * 
      *             
      *             The unique id for an artifact produced by the
      * project group, e.g.
      *             <code>maven-artifact</code>.
      *             
      *           
      */
     private String artifactId;
 
     /**
      * 
      *             
      *             The version of the dependency, e.g.
      * <code>3.2.1</code>. In Maven 2, this can also be
      *             specified as a range of versions.
      *             
      *           
      */
     private String version;
 
     /**
      * 
      *             
      *             The type of dependency. This defaults to
      * <code>jar</code>. While it
      *             usually represents the extension on the filename
      * of the dependency,
      *             that is not always the case. A type can be
      * mapped to a different
      *             extension and a classifier.
      *             The type often correspongs to the packaging
      * used, though this is also
      *             not always the case.
      *             Some examples are <code>jar</code>,
      * <code>war</code>, <code>ejb-client</code>
      *             and <code>test-jar</code>.
      *             New types can be defined by plugins that set
      *             <code>extensions</code> to <code>true</code>, so
      * this is not a complete list.
      *             
      *           
      */
     private String type = "jar";
 
     /**
      * 
      *             
      *             The classifier of the dependency. This allows
      * distinguishing two artifacts
      *             that belong to the same POM but were built
      * differently, and is appended to
      *             the filename after the version. For example,
      * <code>jdk14</code> and <code>jdk15</code>.
      *             
      *           
      */
     private String classifier;
 
     /**
      * 
      *             
      *             The scope of the dependency -
      * <code>compile</code>, <code>runtime</code>,
      *             <code>test</code>, <code>system</code>, and
      * <code>provided</code>. Used to
      *             calculate the various classpaths used for
      * compilation, testing, and so on.
      *             It also assists in determining which artifacts
      * to include in a distribution of
      *             this project. For more information, see
      *             <a
      * href="http://maven.apache.org/guides/introduction/introduction-to-dependency-mechanism.html">the
      *             dependency mechanism</a>.
      *             
      *           
      */
     private String scope;
 
     /**
      * 
      *             
      *             FOR SYSTEM SCOPE ONLY. Note that use of this
      * property is <b>discouraged</b>
      *             and may be replaced in later versions. This
      * specifies the path on the filesystem
      *             for this dependency.
      *             Requires an absolute path for the value, not
      * relative.
      *             Use a property that gives the machine specific
      * absolute path,
      *             e.g. <code>${java.home}</code>.
      *             
      *           
      */
     private String systemPath;
 
     /**
      * Field exclusions.
      */
     private java.util.List exclusions;
 
     /**
      * Indicates the dependency is optional for use of this
      * library. While the
      *             version of the dependency will be taken into
      * account for dependency calculation if the
      *             library is used elsewhere, it will not be passed
      * on transitively.
      */
     private boolean optional = false;
 
 
       //-----------/
      //- Methods -/
     //-----------/
 
     /**
      * Method addExclusion.
      * 
      * @param exclusion
      */
     public void addExclusion( Exclusion exclusion )
     {
         if ( !(exclusion instanceof Exclusion) )
         {
             throw new ClassCastException( "Dependency.addExclusions(exclusion) parameter must be instanceof " + Exclusion.class.getName() );
         }
         getExclusions().add( exclusion );
     } //-- void addExclusion( Exclusion ) 
 
     /**
      * Get 
      *             
      *             The unique id for an artifact produced by the
      * project group, e.g.
      *             <code>maven-artifact</code>.
      *             
      *           
      * 
      * @return String
      */
     public String getArtifactId()
     {
         return this.artifactId;
     } //-- String getArtifactId() 
 
     /**
      * Get 
      *             
      *             The classifier of the dependency. This allows
      * distinguishing two artifacts
      *             that belong to the same POM but were built
      * differently, and is appended to
      *             the filename after the version. For example,
      * <code>jdk14</code> and <code>jdk15</code>.
      *             
      *           
      * 
      * @return String
      */
     public String getClassifier()
     {
         return this.classifier;
     } //-- String getClassifier() 
 
     /**
      * Method getExclusions.
      * 
      * @return java.util.List
      */
     public java.util.List getExclusions()
     {
         if ( this.exclusions == null )
         {
             this.exclusions = new java.util.ArrayList();
         }
     
         return this.exclusions;
     } //-- java.util.List getExclusions() 
 
     /**
      * Get 
      *             
      *             The project group that produced the dependency,
      * e.g.
      *             <code>org.apache.maven</code>.
      *             
      *           
      * 
      * @return String
      */
     public String getGroupId()
     {
         return this.groupId;
     } //-- String getGroupId() 
 
     /**
      * Get 
      *             
      *             The scope of the dependency -
      * <code>compile</code>, <code>runtime</code>,
      *             <code>test</code>, <code>system</code>, and
      * <code>provided</code>. Used to
      *             calculate the various classpaths used for
      * compilation, testing, and so on.
      *             It also assists in determining which artifacts
      * to include in a distribution of
      *             this project. For more information, see
      *             <a
      * href="http://maven.apache.org/guides/introduction/introduction-to-dependency-mechanism.html">the
      *             dependency mechanism</a>.
      *             
      *           
      * 
      * @return String
      */
     public String getScope()
     {
         return this.scope;
     } //-- String getScope() 
 
     /**
      * Get 
      *             
      *             FOR SYSTEM SCOPE ONLY. Note that use of this
      * property is <b>discouraged</b>
      *             and may be replaced in later versions. This
      * specifies the path on the filesystem
      *             for this dependency.
      *             Requires an absolute path for the value, not
      * relative.
      *             Use a property that gives the machine specific
      * absolute path,
      *             e.g. <code>${java.home}</code>.
      *             
      *           
      * 
      * @return String
      */
     public String getSystemPath()
     {
         return this.systemPath;
     } //-- String getSystemPath() 
 
     /**
      * Get 
      *             
      *             The type of dependency. This defaults to
      * <code>jar</code>. While it
      *             usually represents the extension on the filename
      * of the dependency,
      *             that is not always the case. A type can be
      * mapped to a different
      *             extension and a classifier.
      *             The type often correspongs to the packaging
      * used, though this is also
      *             not always the case.
      *             Some examples are <code>jar</code>,
      * <code>war</code>, <code>ejb-client</code>
      *             and <code>test-jar</code>.
      *             New types can be defined by plugins that set
      *             <code>extensions</code> to <code>true</code>, so
      * this is not a complete list.
      *             
      *           
      * 
      * @return String
      */
     public String getType()
     {
         return this.type;
     } //-- String getType() 
 
     /**
      * Get 
      *             
      *             The version of the dependency, e.g.
      * <code>3.2.1</code>. In Maven 2, this can also be
      *             specified as a range of versions.
      *             
      *           
      * 
      * @return String
      */
     public String getVersion()
     {
         return this.version;
     } //-- String getVersion() 
 
     /**
      * Get indicates the dependency is optional for use of this
      * library. While the
      *             version of the dependency will be taken into
      * account for dependency calculation if the
      *             library is used elsewhere, it will not be passed
      * on transitively.
      * 
      * @return boolean
      */
     public boolean isOptional()
     {
         return this.optional;
     } //-- boolean isOptional() 
 
     /**
      * Method removeExclusion.
      * 
      * @param exclusion
      */
     public void removeExclusion( Exclusion exclusion )
     {
         if ( !(exclusion instanceof Exclusion) )
         {
             throw new ClassCastException( "Dependency.removeExclusions(exclusion) parameter must be instanceof " + Exclusion.class.getName() );
         }
         getExclusions().remove( exclusion );
     } //-- void removeExclusion( Exclusion ) 
 
     /**
      * Set 
      *             
      *             The unique id for an artifact produced by the
      * project group, e.g.
      *             <code>maven-artifact</code>.
      *             
      *           
      * 
      * @param artifactId
      */
     public void setArtifactId( String artifactId )
     {
         this.artifactId = artifactId;
     } //-- void setArtifactId( String ) 
 
     /**
      * Set 
      *             
      *             The classifier of the dependency. This allows
      * distinguishing two artifacts
      *             that belong to the same POM but were built
      * differently, and is appended to
      *             the filename after the version. For example,
      * <code>jdk14</code> and <code>jdk15</code>.
      *             
      *           
      * 
      * @param classifier
      */
     public void setClassifier( String classifier )
     {
         this.classifier = classifier;
     } //-- void setClassifier( String ) 
 
     /**
      * Set lists a set of artifacts that should be excluded from
      * this dependency's
      *             artifact list when it comes to calculating
      * transitive dependencies.
      * 
      * @param exclusions
      */
     public void setExclusions( java.util.List exclusions )
     {
         this.exclusions = exclusions;
     } //-- void setExclusions( java.util.List ) 
 
     /**
      * Set 
      *             
      *             The project group that produced the dependency,
      * e.g.
      *             <code>org.apache.maven</code>.
      *             
      *           
      * 
      * @param groupId
      */
     public void setGroupId( String groupId )
     {
         this.groupId = groupId;
     } //-- void setGroupId( String ) 
 
     /**
      * Set indicates the dependency is optional for use of this
      * library. While the
      *             version of the dependency will be taken into
      * account for dependency calculation if the
      *             library is used elsewhere, it will not be passed
      * on transitively.
      * 
      * @param optional
      */
     public void setOptional( boolean optional )
     {
         this.optional = optional;
     } //-- void setOptional( boolean ) 
 
     /**
      * Set 
      *             
      *             The scope of the dependency -
      * <code>compile</code>, <code>runtime</code>,
      *             <code>test</code>, <code>system</code>, and
      * <code>provided</code>. Used to
      *             calculate the various classpaths used for
      * compilation, testing, and so on.
      *             It also assists in determining which artifacts
      * to include in a distribution of
      *             this project. For more information, see
      *             <a
      * href="http://maven.apache.org/guides/introduction/introduction-to-dependency-mechanism.html">the
      *             dependency mechanism</a>.
      *             
      *           
      * 
      * @param scope
      */
     public void setScope( String scope )
     {
         this.scope = scope;
     } //-- void setScope( String ) 
 
     /**
      * Set 
      *             
      *             FOR SYSTEM SCOPE ONLY. Note that use of this
      * property is <b>discouraged</b>
      *             and may be replaced in later versions. This
      * specifies the path on the filesystem
      *             for this dependency.
      *             Requires an absolute path for the value, not
      * relative.
      *             Use a property that gives the machine specific
      * absolute path,
      *             e.g. <code>${java.home}</code>.
      *             
      *           
      * 
      * @param systemPath
      */
     public void setSystemPath( String systemPath )
     {
         this.systemPath = systemPath;
     } //-- void setSystemPath( String ) 
 
     /**
      * Set 
      *             
      *             The type of dependency. This defaults to
      * <code>jar</code>. While it
      *             usually represents the extension on the filename
      * of the dependency,
      *             that is not always the case. A type can be
      * mapped to a different
      *             extension and a classifier.
      *             The type often correspongs to the packaging
      * used, though this is also
      *             not always the case.
      *             Some examples are <code>jar</code>,
      * <code>war</code>, <code>ejb-client</code>
      *             and <code>test-jar</code>.
      *             New types can be defined by plugins that set
      *             <code>extensions</code> to <code>true</code>, so
      * this is not a complete list.
      *             
      *           
      * 
      * @param type
      */
     public void setType( String type )
     {
         this.type = type;
     } //-- void setType( String ) 
 
     /**
      * Set 
      *             
      *             The version of the dependency, e.g.
      * <code>3.2.1</code>. In Maven 2, this can also be
      *             specified as a range of versions.
      *             
      *           
      * 
      * @param version
      */
     public void setVersion( String version )
     {
         this.version = version;
     } //-- void setVersion( String ) 
 
 
             
     /**
      * @see java.lang.Object#toString()
      */
     public String toString()
     {
         return "Dependency {groupId=" + groupId + ", artifactId=" + artifactId + ", version=" + version + ", type=" + type + "}";
     }
             
           
             
     /**
      * @return the management key as <code>groupId:artifactId:type</code>
      */
     public String getManagementKey()
     {
         return groupId + ":" + artifactId + ":" + type + ( classifier != null ? ":" + classifier : "" );
     }
             
           
     private String modelEncoding = "UTF-8";
 
     /**
      * Set an encoding used for reading/writing the model.
      *
      * @param modelEncoding the encoding used when reading/writing the model.
      */
     public void setModelEncoding( String modelEncoding )
     {
         this.modelEncoding = modelEncoding;
     }
 
     /**
      * @return the current encoding used when reading/writing this model.
      */
     public String getModelEncoding()
     {
         return modelEncoding;
     }
 }

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