View Javadoc
1   /*******************************************************************************
2    * Copyright (c) 2010, 2012 Sonatype, Inc.
3    * All rights reserved. This program and the accompanying materials
4    * are made available under the terms of the Eclipse Public License v1.0
5    * which accompanies this distribution, and is available at
6    * http://www.eclipse.org/legal/epl-v10.html
7    *
8    * Contributors:
9    *    Sonatype, Inc. - initial API and implementation
10   *******************************************************************************/
11  package org.eclipse.aether.resolution;
12  
13  import java.util.ArrayList;
14  import java.util.Collection;
15  import java.util.Collections;
16  import java.util.List;
17  import java.util.Map;
18  
19  import org.eclipse.aether.RepositorySystem;
20  import org.eclipse.aether.RepositorySystemSession;
21  import org.eclipse.aether.artifact.Artifact;
22  import org.eclipse.aether.graph.Dependency;
23  import org.eclipse.aether.repository.ArtifactRepository;
24  import org.eclipse.aether.repository.RemoteRepository;
25  
26  /**
27   * The result from reading an artifact descriptor.
28   * 
29   * @see RepositorySystem#readArtifactDescriptor(RepositorySystemSession, ArtifactDescriptorRequest)
30   */
31  public final class ArtifactDescriptorResult
32  {
33  
34      private final ArtifactDescriptorRequest request;
35  
36      private List<Exception> exceptions;
37  
38      private List<Artifact> relocations;
39  
40      private Collection<Artifact> aliases;
41  
42      private Artifact artifact;
43  
44      private ArtifactRepository repository;
45  
46      private List<Dependency> dependencies;
47  
48      private List<Dependency> managedDependencies;
49  
50      private List<RemoteRepository> repositories;
51  
52      private Map<String, Object> properties;
53  
54      /**
55       * Creates a new result for the specified request.
56       * 
57       * @param request The descriptor request, must not be {@code null}.
58       */
59      public ArtifactDescriptorResult( ArtifactDescriptorRequest request )
60      {
61          if ( request == null )
62          {
63              throw new IllegalArgumentException( "artifact descriptor request has not been specified" );
64          }
65          this.request = request;
66          artifact = request.getArtifact();
67          exceptions = Collections.emptyList();
68          relocations = Collections.emptyList();
69          aliases = Collections.emptyList();
70          dependencies = managedDependencies = Collections.emptyList();
71          repositories = Collections.emptyList();
72          properties = Collections.emptyMap();
73      }
74  
75      /**
76       * Gets the descriptor request that was made.
77       * 
78       * @return The descriptor request, never {@code null}.
79       */
80      public ArtifactDescriptorRequest getRequest()
81      {
82          return request;
83      }
84  
85      /**
86       * Gets the exceptions that occurred while reading the artifact descriptor.
87       * 
88       * @return The exceptions that occurred, never {@code null}.
89       */
90      public List<Exception> getExceptions()
91      {
92          return exceptions;
93      }
94  
95      /**
96       * Sets the exceptions that occurred while reading the artifact descriptor.
97       * 
98       * @param exceptions The exceptions that occurred, may be {@code null}.
99       * @return This result for chaining, never {@code null}.
100      */
101     public ArtifactDescriptorResult setExceptions( List<Exception> exceptions )
102     {
103         if ( exceptions == null )
104         {
105             this.exceptions = Collections.emptyList();
106         }
107         else
108         {
109             this.exceptions = exceptions;
110         }
111         return this;
112     }
113 
114     /**
115      * Records the specified exception while reading the artifact descriptor.
116      * 
117      * @param exception The exception to record, may be {@code null}.
118      * @return This result for chaining, never {@code null}.
119      */
120     public ArtifactDescriptorResult addException( Exception exception )
121     {
122         if ( exception != null )
123         {
124             if ( exceptions.isEmpty() )
125             {
126                 exceptions = new ArrayList<Exception>();
127             }
128             exceptions.add( exception );
129         }
130         return this;
131     }
132 
133     /**
134      * Gets the relocations that were processed to read the artifact descriptor. The returned list denotes the hops that
135      * lead to the final artifact coordinates as given by {@link #getArtifact()}.
136      * 
137      * @return The relocations that were processed, never {@code null}.
138      */
139     public List<Artifact> getRelocations()
140     {
141         return relocations;
142     }
143 
144     /**
145      * Sets the relocations that were processed to read the artifact descriptor.
146      * 
147      * @param relocations The relocations that were processed, may be {@code null}.
148      * @return This result for chaining, never {@code null}.
149      */
150     public ArtifactDescriptorResult setRelocations( List<Artifact> relocations )
151     {
152         if ( relocations == null )
153         {
154             this.relocations = Collections.emptyList();
155         }
156         else
157         {
158             this.relocations = relocations;
159         }
160         return this;
161     }
162 
163     /**
164      * Records the specified relocation hop while locating the artifact descriptor.
165      * 
166      * @param artifact The artifact that got relocated, may be {@code null}.
167      * @return This result for chaining, never {@code null}.
168      */
169     public ArtifactDescriptorResult addRelocation( Artifact artifact )
170     {
171         if ( artifact != null )
172         {
173             if ( relocations.isEmpty() )
174             {
175                 relocations = new ArrayList<Artifact>();
176             }
177             relocations.add( artifact );
178         }
179         return this;
180     }
181 
182     /**
183      * Gets the known aliases for this artifact. An alias denotes a different artifact with (almost) the same contents
184      * and can be used to mark a patched rebuild of some other artifact as such, thereby allowing conflict resolution to
185      * consider the patched and the original artifact as a conflict.
186      * 
187      * @return The aliases of the artifact, never {@code null}.
188      */
189     public Collection<Artifact> getAliases()
190     {
191         return aliases;
192     }
193 
194     /**
195      * Sets the aliases of the artifact.
196      * 
197      * @param aliases The aliases of the artifact, may be {@code null}.
198      * @return This result for chaining, never {@code null}.
199      */
200     public ArtifactDescriptorResult setAliases( Collection<Artifact> aliases )
201     {
202         if ( aliases == null )
203         {
204             this.aliases = Collections.emptyList();
205         }
206         else
207         {
208             this.aliases = aliases;
209         }
210         return this;
211     }
212 
213     /**
214      * Records the specified alias.
215      * 
216      * @param alias The alias for the artifact, may be {@code null}.
217      * @return This result for chaining, never {@code null}.
218      */
219     public ArtifactDescriptorResult addAlias( Artifact alias )
220     {
221         if ( alias != null )
222         {
223             if ( aliases.isEmpty() )
224             {
225                 aliases = new ArrayList<Artifact>();
226             }
227             aliases.add( alias );
228         }
229         return this;
230     }
231 
232     /**
233      * Gets the artifact whose descriptor was read. This can be a different artifact than originally requested in case
234      * relocations were encountered.
235      * 
236      * @return The artifact after following any relocations, never {@code null}.
237      */
238     public Artifact getArtifact()
239     {
240         return artifact;
241     }
242 
243     /**
244      * Sets the artifact whose descriptor was read.
245      * 
246      * @param artifact The artifact whose descriptor was read, may be {@code null}.
247      * @return This result for chaining, never {@code null}.
248      */
249     public ArtifactDescriptorResult setArtifact( Artifact artifact )
250     {
251         this.artifact = artifact;
252         return this;
253     }
254 
255     /**
256      * Gets the repository from which the descriptor was eventually resolved.
257      * 
258      * @return The repository from which the descriptor was resolved or {@code null} if unknown.
259      */
260     public ArtifactRepository getRepository()
261     {
262         return repository;
263     }
264 
265     /**
266      * Sets the repository from which the descriptor was resolved.
267      * 
268      * @param repository The repository from which the descriptor was resolved, may be {@code null}.
269      * @return This result for chaining, never {@code null}.
270      */
271     public ArtifactDescriptorResult setRepository( ArtifactRepository repository )
272     {
273         this.repository = repository;
274         return this;
275     }
276 
277     /**
278      * Gets the list of direct dependencies of the artifact.
279      * 
280      * @return The list of direct dependencies, never {@code null}
281      */
282     public List<Dependency> getDependencies()
283     {
284         return dependencies;
285     }
286 
287     /**
288      * Sets the list of direct dependencies of the artifact.
289      * 
290      * @param dependencies The list of direct dependencies, may be {@code null}
291      * @return This result for chaining, never {@code null}.
292      */
293     public ArtifactDescriptorResult setDependencies( List<Dependency> dependencies )
294     {
295         if ( dependencies == null )
296         {
297             this.dependencies = Collections.emptyList();
298         }
299         else
300         {
301             this.dependencies = dependencies;
302         }
303         return this;
304     }
305 
306     /**
307      * Adds the specified direct dependency.
308      * 
309      * @param dependency The direct dependency to add, may be {@code null}.
310      * @return This result for chaining, never {@code null}.
311      */
312     public ArtifactDescriptorResult addDependency( Dependency dependency )
313     {
314         if ( dependency != null )
315         {
316             if ( dependencies.isEmpty() )
317             {
318                 dependencies = new ArrayList<Dependency>();
319             }
320             dependencies.add( dependency );
321         }
322         return this;
323     }
324 
325     /**
326      * Gets the dependency management information.
327      * 
328      * @return The dependency management information.
329      */
330     public List<Dependency> getManagedDependencies()
331     {
332         return managedDependencies;
333     }
334 
335     /**
336      * Sets the dependency management information.
337      * 
338      * @param dependencies The dependency management information, may be {@code null}.
339      * @return This result for chaining, never {@code null}.
340      */
341     public ArtifactDescriptorResult setManagedDependencies( List<Dependency> dependencies )
342     {
343         if ( dependencies == null )
344         {
345             this.managedDependencies = Collections.emptyList();
346         }
347         else
348         {
349             this.managedDependencies = dependencies;
350         }
351         return this;
352     }
353 
354     /**
355      * Adds the specified managed dependency.
356      * 
357      * @param dependency The managed dependency to add, may be {@code null}.
358      * @return This result for chaining, never {@code null}.
359      */
360     public ArtifactDescriptorResult addManagedDependency( Dependency dependency )
361     {
362         if ( dependency != null )
363         {
364             if ( managedDependencies.isEmpty() )
365             {
366                 managedDependencies = new ArrayList<Dependency>();
367             }
368             managedDependencies.add( dependency );
369         }
370         return this;
371     }
372 
373     /**
374      * Gets the remote repositories listed in the artifact descriptor.
375      * 
376      * @return The remote repositories listed in the artifact descriptor, never {@code null}.
377      */
378     public List<RemoteRepository> getRepositories()
379     {
380         return repositories;
381     }
382 
383     /**
384      * Sets the remote repositories listed in the artifact descriptor.
385      * 
386      * @param repositories The remote repositories listed in the artifact descriptor, may be {@code null}.
387      * @return This result for chaining, never {@code null}.
388      */
389     public ArtifactDescriptorResult setRepositories( List<RemoteRepository> repositories )
390     {
391         if ( repositories == null )
392         {
393             this.repositories = Collections.emptyList();
394         }
395         else
396         {
397             this.repositories = repositories;
398         }
399         return this;
400     }
401 
402     /**
403      * Adds the specified remote repository.
404      * 
405      * @param repository The remote repository to add, may be {@code null}.
406      * @return This result for chaining, never {@code null}.
407      */
408     public ArtifactDescriptorResult addRepository( RemoteRepository repository )
409     {
410         if ( repository != null )
411         {
412             if ( repositories.isEmpty() )
413             {
414                 repositories = new ArrayList<RemoteRepository>();
415             }
416             repositories.add( repository );
417         }
418         return this;
419     }
420 
421     /**
422      * Gets any additional information about the artifact in form of key-value pairs. <em>Note:</em> Regardless of their
423      * actual type, all property values must be treated as being read-only.
424      * 
425      * @return The additional information about the artifact, never {@code null}.
426      */
427     public Map<String, Object> getProperties()
428     {
429         return properties;
430     }
431 
432     /**
433      * Sets any additional information about the artifact in form of key-value pairs.
434      * 
435      * @param properties The additional information about the artifact, may be {@code null}.
436      * @return This result for chaining, never {@code null}.
437      */
438     public ArtifactDescriptorResult setProperties( Map<String, Object> properties )
439     {
440         if ( properties == null )
441         {
442             this.properties = Collections.emptyMap();
443         }
444         else
445         {
446             this.properties = properties;
447         }
448         return this;
449     }
450 
451     @Override
452     public String toString()
453     {
454         return getArtifact() + " -> " + getDependencies();
455     }
456 
457 }