001package org.apache.maven.artifact.resolver;
002
003/*
004 * Licensed to the Apache Software Foundation (ASF) under one
005 * or more contributor license agreements.  See the NOTICE file
006 * distributed with this work for additional information
007 * regarding copyright ownership.  The ASF licenses this file
008 * to you under the Apache License, Version 2.0 (the
009 * "License"); you may not use this file except in compliance
010 * with the License.  You may obtain a copy of the License at
011 *
012 *  http://www.apache.org/licenses/LICENSE-2.0
013 *
014 * Unless required by applicable law or agreed to in writing,
015 * software distributed under the License is distributed on an
016 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
017 * KIND, either express or implied.  See the License for the
018 * specific language governing permissions and limitations
019 * under the License.
020 */
021
022import java.util.ArrayList;
023import java.util.Collections;
024import java.util.LinkedHashSet;
025import java.util.List;
026import java.util.Set;
027
028import org.apache.maven.artifact.Artifact;
029import org.apache.maven.artifact.repository.ArtifactRepository;
030import org.apache.maven.artifact.versioning.OverConstrainedVersionException;
031
032/**
033 * Specific problems during resolution that we want to account for:
034 * <p/>
035 * - missing metadata - version range violations - version circular dependencies - missing artifacts
036 * - network/transfer errors - file system errors: permissions
037 *
038 * @author Jason van Zyl
039 * @TODO carlos: all these possible has*Exceptions and get*Exceptions methods make the clients too
040 *       complex requiring a long list of checks, need to create a parent/interfact/encapsulation
041 *       for the types of exceptions
042 */
043public class ArtifactResolutionResult
044{
045    private Artifact originatingArtifact;
046
047    private List<Artifact> missingArtifacts;
048
049    // Exceptions
050
051    private List<Exception> exceptions;
052
053    private List<Exception> versionRangeViolations;
054
055    private List<ArtifactResolutionException> metadataResolutionExceptions;
056
057    private List<CyclicDependencyException> circularDependencyExceptions;
058
059    private List<ArtifactResolutionException> errorArtifactExceptions;
060
061    // file system errors
062
063    private List<ArtifactRepository> repositories;
064
065    private Set<Artifact> artifacts;
066
067    private Set<ResolutionNode> resolutionNodes;
068
069    public Artifact getOriginatingArtifact()
070    {
071        return originatingArtifact;
072    }
073
074    public ArtifactResolutionResult setOriginatingArtifact( final Artifact originatingArtifact )
075    {
076        this.originatingArtifact = originatingArtifact;
077
078        return this;
079    }
080
081    public void addArtifact( Artifact artifact )
082    {
083        if ( artifacts == null )
084        {
085            artifacts = new LinkedHashSet<Artifact>();
086        }
087
088        artifacts.add( artifact );
089    }
090
091    public Set<Artifact> getArtifacts()
092    {
093        if ( artifacts == null )
094        {
095            artifacts = new LinkedHashSet<Artifact>();
096        }
097
098        return artifacts;
099    }
100
101    public void setArtifacts( Set<Artifact> artifacts )
102    {
103        this.artifacts = artifacts;
104    }
105
106    public Set<ResolutionNode> getArtifactResolutionNodes()
107    {
108        if ( resolutionNodes == null )
109        {
110            resolutionNodes = new LinkedHashSet<ResolutionNode>();
111        }
112
113        return resolutionNodes;
114    }
115
116    public void setArtifactResolutionNodes( Set<ResolutionNode> resolutionNodes )
117    {
118        this.resolutionNodes = resolutionNodes;
119    }
120
121    public boolean hasMissingArtifacts()
122    {
123        return missingArtifacts != null && !missingArtifacts.isEmpty();
124    }
125
126    public List<Artifact> getMissingArtifacts()
127    {
128        return missingArtifacts == null ? Collections.<Artifact> emptyList() : missingArtifacts;
129    }
130
131    public ArtifactResolutionResult addMissingArtifact( Artifact artifact )
132    {
133        missingArtifacts = initList( missingArtifacts );
134
135        missingArtifacts.add( artifact );
136
137        return this;
138    }
139
140    public ArtifactResolutionResult setUnresolvedArtifacts( final List<Artifact> unresolvedArtifacts )
141    {
142        this.missingArtifacts = unresolvedArtifacts;
143
144        return this;
145    }
146
147    public boolean isSuccess()
148    {
149        return !( hasMissingArtifacts() || hasExceptions() );
150    }
151
152    // ------------------------------------------------------------------------
153    // Exceptions
154    // ------------------------------------------------------------------------
155
156    public boolean hasExceptions()
157    {
158        return exceptions != null && !exceptions.isEmpty();
159    }
160
161    public List<Exception> getExceptions()
162    {
163        return exceptions == null ? Collections.<Exception> emptyList() : exceptions;
164    }
165
166    // ------------------------------------------------------------------------
167    // Version Range Violations
168    // ------------------------------------------------------------------------
169
170    public boolean hasVersionRangeViolations()
171    {
172        return versionRangeViolations != null;
173    }
174
175    /**
176     * @TODO this needs to accept a {@link OverConstrainedVersionException} as returned by
177     *       {@link #getVersionRangeViolation(int)} but it's not used like that in
178     *       {@link DefaultLegacyArtifactCollector}
179     */
180    public ArtifactResolutionResult addVersionRangeViolation( Exception e )
181    {
182        versionRangeViolations = initList( versionRangeViolations );
183
184        versionRangeViolations.add( e );
185
186        exceptions = initList( exceptions );
187
188        exceptions.add( e );
189
190        return this;
191    }
192
193    public OverConstrainedVersionException getVersionRangeViolation( int i )
194    {
195        return (OverConstrainedVersionException) versionRangeViolations.get( i );
196    }
197
198    public List<Exception> getVersionRangeViolations()
199    {
200        return versionRangeViolations == null ? Collections.<Exception> emptyList() : versionRangeViolations;
201    }
202
203    // ------------------------------------------------------------------------
204    // Metadata Resolution Exceptions: ArtifactResolutionExceptions
205    // ------------------------------------------------------------------------
206
207    public boolean hasMetadataResolutionExceptions()
208    {
209        return metadataResolutionExceptions != null;
210    }
211
212    public ArtifactResolutionResult addMetadataResolutionException( ArtifactResolutionException e )
213    {
214        metadataResolutionExceptions = initList( metadataResolutionExceptions );
215
216        metadataResolutionExceptions.add( e );
217
218        exceptions = initList( exceptions );
219
220        exceptions.add( e );
221
222        return this;
223    }
224
225    public ArtifactResolutionException getMetadataResolutionException( int i )
226    {
227        return metadataResolutionExceptions.get( i );
228    }
229
230    public List<ArtifactResolutionException> getMetadataResolutionExceptions()
231    {
232        return metadataResolutionExceptions == null ? Collections.<ArtifactResolutionException> emptyList()
233                        : metadataResolutionExceptions;
234    }
235
236    // ------------------------------------------------------------------------
237    // ErrorArtifactExceptions: ArtifactResolutionExceptions
238    // ------------------------------------------------------------------------
239
240    public boolean hasErrorArtifactExceptions()
241    {
242        return errorArtifactExceptions != null;
243    }
244
245    public ArtifactResolutionResult addErrorArtifactException( ArtifactResolutionException e )
246    {
247        errorArtifactExceptions = initList( errorArtifactExceptions );
248
249        errorArtifactExceptions.add( e );
250
251        exceptions = initList( exceptions );
252
253        exceptions.add( e );
254
255        return this;
256    }
257
258    public List<ArtifactResolutionException> getErrorArtifactExceptions()
259    {
260        if ( errorArtifactExceptions == null )
261        {
262            return Collections.emptyList();
263        }
264
265        return errorArtifactExceptions;
266    }
267
268    // ------------------------------------------------------------------------
269    // Circular Dependency Exceptions
270    // ------------------------------------------------------------------------
271
272    public boolean hasCircularDependencyExceptions()
273    {
274        return circularDependencyExceptions != null;
275    }
276
277    public ArtifactResolutionResult addCircularDependencyException( CyclicDependencyException e )
278    {
279        circularDependencyExceptions = initList( circularDependencyExceptions );
280
281        circularDependencyExceptions.add( e );
282
283        exceptions = initList( exceptions );
284
285        exceptions.add( e );
286
287        return this;
288    }
289
290    public CyclicDependencyException getCircularDependencyException( int i )
291    {
292        return circularDependencyExceptions.get( i );
293    }
294
295    public List<CyclicDependencyException> getCircularDependencyExceptions()
296    {
297        if ( circularDependencyExceptions == null )
298        {
299            return Collections.emptyList();
300        }
301
302        return circularDependencyExceptions;
303    }
304
305    // ------------------------------------------------------------------------
306    // Repositories
307    // ------------------------------------------------------------------------
308
309    public List<ArtifactRepository> getRepositories()
310    {
311        if ( repositories == null )
312        {
313            return Collections.emptyList();
314        }
315
316        return repositories;
317    }
318
319    public ArtifactResolutionResult setRepositories( final List<ArtifactRepository> repositories )
320    {
321        this.repositories = repositories;
322
323        return this;
324    }
325
326    //
327    // Internal
328    //
329
330    private <T> List<T> initList( final List<T> l )
331    {
332        if ( l == null )
333        {
334            return new ArrayList<T>();
335        }
336        return l;
337    }
338
339    public String toString()
340    {
341        StringBuilder sb = new StringBuilder();
342
343        if ( artifacts != null )
344        {
345            int i = 1;
346            sb.append( "---------" ).append( "\n" );
347            sb.append( artifacts.size() ).append( "\n" );
348            for ( Artifact a : artifacts )
349            {
350                sb.append( i ).append( " " ).append( a ).append( "\n" );
351                i++;
352            }
353            sb.append( "---------" ).append( "\n" );
354        }
355
356        return sb.toString();
357    }
358}