1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19 package org.apache.maven.repository;
20
21 import java.util.ArrayList;
22 import java.util.Collections;
23 import java.util.LinkedHashSet;
24 import java.util.List;
25 import java.util.Set;
26
27 import org.apache.maven.artifact.Artifact;
28 import org.apache.maven.artifact.repository.ArtifactRepository;
29 import org.apache.maven.artifact.resolver.ArtifactResolutionException;
30 import org.apache.maven.artifact.resolver.CyclicDependencyException;
31 import org.apache.maven.artifact.versioning.OverConstrainedVersionException;
32
33
34
35
36
37
38 @Deprecated
39 public class MetadataResolutionResult {
40 private Artifact originatingArtifact;
41
42 private List<Artifact> missingArtifacts;
43
44
45
46 private List<Exception> exceptions;
47
48 private List<Exception> versionRangeViolations;
49
50 private List<ArtifactResolutionException> metadataResolutionExceptions;
51
52 private List<CyclicDependencyException> circularDependencyExceptions;
53
54 private List<ArtifactResolutionException> errorArtifactExceptions;
55
56
57
58 private List<ArtifactRepository> repositories;
59
60 private Set<Artifact> requestedArtifacts;
61
62 private Set<Artifact> artifacts;
63
64 private MetadataGraph dirtyTree;
65
66 private MetadataGraph resolvedTree;
67
68 private MetadataGraph resolvedGraph;
69
70 public Artifact getOriginatingArtifact() {
71 return originatingArtifact;
72 }
73
74 public MetadataResolutionResult listOriginatingArtifact(final Artifact originatingArtifact) {
75 this.originatingArtifact = originatingArtifact;
76
77 return this;
78 }
79
80 public void addArtifact(Artifact artifact) {
81 if (artifacts == null) {
82 artifacts = new LinkedHashSet<>();
83 }
84
85 artifacts.add(artifact);
86 }
87
88 public Set<Artifact> getArtifacts() {
89 return artifacts;
90 }
91
92 public void addRequestedArtifact(Artifact artifact) {
93 if (requestedArtifacts == null) {
94 requestedArtifacts = new LinkedHashSet<>();
95 }
96
97 requestedArtifacts.add(artifact);
98 }
99
100 public Set<Artifact> getRequestedArtifacts() {
101 return requestedArtifacts;
102 }
103
104 public boolean hasMissingArtifacts() {
105 return missingArtifacts != null && !missingArtifacts.isEmpty();
106 }
107
108 public List<Artifact> getMissingArtifacts() {
109 return missingArtifacts == null ? Collections.emptyList() : Collections.unmodifiableList(missingArtifacts);
110 }
111
112 public MetadataResolutionResult addMissingArtifact(Artifact artifact) {
113 missingArtifacts = initList(missingArtifacts);
114
115 missingArtifacts.add(artifact);
116
117 return this;
118 }
119
120 public MetadataResolutionResult setUnresolvedArtifacts(final List<Artifact> unresolvedArtifacts) {
121 this.missingArtifacts = unresolvedArtifacts;
122
123 return this;
124 }
125
126
127
128
129
130 public boolean hasExceptions() {
131 return exceptions != null && !exceptions.isEmpty();
132 }
133
134 public List<Exception> getExceptions() {
135 return exceptions == null ? Collections.emptyList() : Collections.unmodifiableList(exceptions);
136 }
137
138
139
140
141
142 public boolean hasVersionRangeViolations() {
143 return versionRangeViolations != null;
144 }
145
146
147
148
149
150
151 public MetadataResolutionResult addVersionRangeViolation(Exception e) {
152 versionRangeViolations = initList(versionRangeViolations);
153
154 versionRangeViolations.add(e);
155
156 exceptions = initList(exceptions);
157
158 exceptions.add(e);
159
160 return this;
161 }
162
163 public OverConstrainedVersionException getVersionRangeViolation(int i) {
164 return (OverConstrainedVersionException) versionRangeViolations.get(i);
165 }
166
167 public List<Exception> getVersionRangeViolations() {
168 return versionRangeViolations == null
169 ? Collections.emptyList()
170 : Collections.unmodifiableList(versionRangeViolations);
171 }
172
173
174
175
176
177 public boolean hasMetadataResolutionExceptions() {
178 return metadataResolutionExceptions != null;
179 }
180
181 public MetadataResolutionResult addMetadataResolutionException(ArtifactResolutionException e) {
182 metadataResolutionExceptions = initList(metadataResolutionExceptions);
183
184 metadataResolutionExceptions.add(e);
185
186 exceptions = initList(exceptions);
187
188 exceptions.add(e);
189
190 return this;
191 }
192
193 public ArtifactResolutionException getMetadataResolutionException(int i) {
194 return metadataResolutionExceptions.get(i);
195 }
196
197 public List<ArtifactResolutionException> getMetadataResolutionExceptions() {
198 return metadataResolutionExceptions == null
199 ? Collections.emptyList()
200 : Collections.unmodifiableList(metadataResolutionExceptions);
201 }
202
203
204
205
206
207 public boolean hasErrorArtifactExceptions() {
208 return errorArtifactExceptions != null;
209 }
210
211 public MetadataResolutionResult addError(Exception e) {
212 exceptions = initList(exceptions);
213
214 exceptions.add(e);
215
216 return this;
217 }
218
219 public List<ArtifactResolutionException> getErrorArtifactExceptions() {
220 if (errorArtifactExceptions == null) {
221 return Collections.emptyList();
222 }
223
224 return Collections.unmodifiableList(errorArtifactExceptions);
225 }
226
227
228
229
230
231 public boolean hasCircularDependencyExceptions() {
232 return circularDependencyExceptions != null;
233 }
234
235 public MetadataResolutionResult addCircularDependencyException(CyclicDependencyException e) {
236 circularDependencyExceptions = initList(circularDependencyExceptions);
237
238 circularDependencyExceptions.add(e);
239
240 exceptions = initList(exceptions);
241
242 exceptions.add(e);
243
244 return this;
245 }
246
247 public CyclicDependencyException getCircularDependencyException(int i) {
248 return circularDependencyExceptions.get(i);
249 }
250
251 public List<CyclicDependencyException> getCircularDependencyExceptions() {
252 if (circularDependencyExceptions == null) {
253 return Collections.emptyList();
254 }
255
256 return Collections.unmodifiableList(circularDependencyExceptions);
257 }
258
259
260
261
262
263 public List<ArtifactRepository> getRepositories() {
264 if (repositories == null) {
265 return Collections.emptyList();
266 }
267
268 return Collections.unmodifiableList(repositories);
269 }
270
271 public MetadataResolutionResult setRepositories(final List<ArtifactRepository> repositories) {
272 this.repositories = repositories;
273
274 return this;
275 }
276
277
278
279
280
281 private <T> List<T> initList(final List<T> l) {
282 if (l == null) {
283 return new ArrayList<>();
284 }
285 return l;
286 }
287
288 public String toString() {
289 if (artifacts == null) {
290 return "";
291 }
292 StringBuilder sb = new StringBuilder(256);
293 int i = 1;
294 sb.append("---------\n");
295 sb.append(artifacts.size()).append('\n');
296 for (Artifact a : artifacts) {
297 sb.append(i).append(' ').append(a).append('\n');
298 i++;
299 }
300 sb.append("---------\n");
301 return sb.toString();
302 }
303
304 public MetadataGraph getResolvedTree() {
305 return resolvedTree;
306 }
307
308 public void setResolvedTree(MetadataGraph resolvedTree) {
309 this.resolvedTree = resolvedTree;
310 }
311 }