001    package org.apache.maven.repository;
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    
022    import java.util.ArrayList;
023    import java.util.Collections;
024    import java.util.LinkedHashSet;
025    import java.util.List;
026    import java.util.Set;
027    
028    import org.apache.maven.artifact.Artifact;
029    import org.apache.maven.artifact.repository.ArtifactRepository;
030    import org.apache.maven.artifact.resolver.ArtifactResolutionException;
031    import org.apache.maven.artifact.resolver.CyclicDependencyException;
032    import org.apache.maven.artifact.versioning.OverConstrainedVersionException;
033    
034    /**
035     *
036     *
037     * @author Oleg Gusakov
038     *
039     */
040    public class MetadataResolutionResult
041    {
042        private Artifact originatingArtifact;
043    
044        private List<Artifact> missingArtifacts;
045    
046        // Exceptions
047    
048        private List<Exception> exceptions;
049    
050        private List<Exception> versionRangeViolations;
051    
052        private List<ArtifactResolutionException> metadataResolutionExceptions;
053    
054        private List<CyclicDependencyException> circularDependencyExceptions;
055    
056        private List<ArtifactResolutionException> errorArtifactExceptions;
057    
058        // file system errors
059    
060        private List<ArtifactRepository> repositories;
061    
062        private Set<Artifact> requestedArtifacts;
063    
064        private Set<Artifact> artifacts;
065    
066        private MetadataGraph dirtyTree;
067    
068        private MetadataGraph resolvedTree;
069    
070        private MetadataGraph resolvedGraph;
071    
072        public Artifact getOriginatingArtifact()
073        {
074            return originatingArtifact;
075        }
076    
077        public MetadataResolutionResult ListOriginatingArtifact( final Artifact originatingArtifact )
078        {
079            this.originatingArtifact = originatingArtifact;
080    
081            return this;
082        }
083    
084        public void addArtifact( Artifact artifact )
085        {
086            if ( artifacts == null )
087            {
088                artifacts = new LinkedHashSet<Artifact>();
089            }
090    
091            artifacts.add( artifact );
092        }
093    
094        public Set<Artifact> getArtifacts()
095        {
096            return artifacts;
097        }
098    
099        public void addRequestedArtifact( Artifact artifact )
100        {
101            if ( requestedArtifacts == null )
102            {
103                requestedArtifacts = new LinkedHashSet<Artifact>();
104            }
105    
106            requestedArtifacts.add( artifact );
107        }
108    
109        public Set<Artifact> getRequestedArtifacts()
110        {
111            return requestedArtifacts;
112        }
113    
114        public boolean hasMissingArtifacts()
115        {
116            return missingArtifacts != null && !missingArtifacts.isEmpty();
117        }
118    
119        public List<Artifact> getMissingArtifacts()
120        {
121            return missingArtifacts == null ? Collections.<Artifact> emptyList() : missingArtifacts;
122        }
123    
124        public MetadataResolutionResult addMissingArtifact( Artifact artifact )
125        {
126            missingArtifacts = initList( missingArtifacts );
127    
128            missingArtifacts.add( artifact );
129    
130            return this;
131        }
132    
133        public MetadataResolutionResult setUnresolvedArtifacts( final List<Artifact> unresolvedArtifacts )
134        {
135            this.missingArtifacts = unresolvedArtifacts;
136    
137            return this;
138        }
139    
140        // ------------------------------------------------------------------------
141        // Exceptions
142        // ------------------------------------------------------------------------
143    
144        public boolean hasExceptions()
145        {
146            return exceptions != null && !exceptions.isEmpty();
147        }
148    
149        public List<Exception> getExceptions()
150        {
151            return exceptions == null ? Collections.<Exception> emptyList() : exceptions;
152        }
153    
154        // ------------------------------------------------------------------------
155        // Version Range Violations
156        // ------------------------------------------------------------------------
157    
158        public boolean hasVersionRangeViolations()
159        {
160            return versionRangeViolations != null;
161        }
162    
163        /**
164         * @TODO this needs to accept a {@link OverConstrainedVersionException} as returned by
165         *       {@link #getVersionRangeViolation(int)} but it's not used like that in
166         *       {@link DefaultLegacyArtifactCollector}
167         */
168        public MetadataResolutionResult addVersionRangeViolation( Exception e )
169        {
170            versionRangeViolations = initList( versionRangeViolations );
171    
172            versionRangeViolations.add( e );
173    
174            exceptions = initList( exceptions );
175    
176            exceptions.add( e );
177    
178            return this;
179        }
180    
181        public OverConstrainedVersionException getVersionRangeViolation( int i )
182        {
183            return (OverConstrainedVersionException) versionRangeViolations.get( i );
184        }
185    
186        public List<Exception> getVersionRangeViolations()
187        {
188            return versionRangeViolations == null ? Collections.<Exception> emptyList() : versionRangeViolations;
189        }
190    
191        // ------------------------------------------------------------------------
192        // Metadata Resolution Exceptions: ArtifactResolutionExceptions
193        // ------------------------------------------------------------------------
194    
195        public boolean hasMetadataResolutionExceptions()
196        {
197            return metadataResolutionExceptions != null;
198        }
199    
200        public MetadataResolutionResult addMetadataResolutionException( ArtifactResolutionException e )
201        {
202            metadataResolutionExceptions = initList( metadataResolutionExceptions );
203    
204            metadataResolutionExceptions.add( e );
205    
206            exceptions = initList( exceptions );
207    
208            exceptions.add( e );
209    
210            return this;
211        }
212    
213        public ArtifactResolutionException getMetadataResolutionException( int i )
214        {
215            return metadataResolutionExceptions.get( i );
216        }
217    
218        public List<ArtifactResolutionException> getMetadataResolutionExceptions()
219        {
220            return metadataResolutionExceptions == null ? Collections.<ArtifactResolutionException> emptyList()
221                            : metadataResolutionExceptions;
222        }
223    
224        // ------------------------------------------------------------------------
225        // ErrorArtifactExceptions: ArtifactResolutionExceptions
226        // ------------------------------------------------------------------------
227    
228        public boolean hasErrorArtifactExceptions()
229        {
230            return errorArtifactExceptions != null;
231        }
232    
233        public MetadataResolutionResult addError( Exception e )
234        {
235            if ( exceptions == null )
236            {
237                initList( exceptions );
238            }
239    
240            exceptions.add( e );
241    
242            return this;
243        }
244    
245        public List<ArtifactResolutionException> getErrorArtifactExceptions()
246        {
247            if ( errorArtifactExceptions == null )
248            {
249                return Collections.emptyList();
250            }
251    
252            return errorArtifactExceptions;
253        }
254    
255        // ------------------------------------------------------------------------
256        // Circular Dependency Exceptions
257        // ------------------------------------------------------------------------
258    
259        public boolean hasCircularDependencyExceptions()
260        {
261            return circularDependencyExceptions != null;
262        }
263    
264        public MetadataResolutionResult addCircularDependencyException( CyclicDependencyException e )
265        {
266            circularDependencyExceptions = initList( circularDependencyExceptions );
267    
268            circularDependencyExceptions.add( e );
269    
270            exceptions = initList( exceptions );
271    
272            exceptions.add( e );
273    
274            return this;
275        }
276    
277        public CyclicDependencyException getCircularDependencyException( int i )
278        {
279            return circularDependencyExceptions.get( i );
280        }
281    
282        public List<CyclicDependencyException> getCircularDependencyExceptions()
283        {
284            if ( circularDependencyExceptions == null )
285            {
286                return Collections.emptyList();
287            }
288    
289            return circularDependencyExceptions;
290        }
291    
292        // ------------------------------------------------------------------------
293        // Repositories
294        // ------------------------------------------------------------------------
295    
296        public List<ArtifactRepository> getRepositories()
297        {
298            if ( repositories == null )
299            {
300                return Collections.emptyList();
301            }
302    
303            return repositories;
304        }
305    
306        public MetadataResolutionResult setRepositories( final List<ArtifactRepository> repositories )
307        {
308            this.repositories = repositories;
309    
310            return this;
311        }
312    
313        //
314        // Internal
315        //
316    
317        private <T> List<T> initList( final List<T> l )
318        {
319            if ( l == null )
320            {
321                return new ArrayList<T>();
322            }
323            return l;
324        }
325    
326        public String toString()
327        {
328            StringBuilder sb = new StringBuilder();
329    
330            if ( artifacts != null )
331            {
332                int i = 1;
333                sb.append( "---------" ).append( "\n" );
334                sb.append( artifacts.size() ).append( "\n" );
335                for ( Artifact a : artifacts )
336                {
337                    sb.append( i ).append( " " ).append( a ).append( "\n" );
338                    i++;
339                }
340                sb.append( "---------" ).append( "\n" );
341            }
342    
343            return sb.toString();
344        }
345    
346        public MetadataGraph getResolvedTree()
347        {
348            return resolvedTree;
349        }
350    
351        public void setResolvedTree( MetadataGraph resolvedTree )
352        {
353            this.resolvedTree = resolvedTree;
354        }
355    
356    }