1
2
3
4
5
6
7
8
9
10
11 package org.eclipse.aether.graph;
12
13 import java.util.ArrayList;
14 import java.util.Collection;
15 import java.util.Collections;
16 import java.util.HashMap;
17 import java.util.List;
18 import java.util.Map;
19
20 import org.eclipse.aether.artifact.Artifact;
21 import org.eclipse.aether.repository.RemoteRepository;
22 import org.eclipse.aether.version.Version;
23 import org.eclipse.aether.version.VersionConstraint;
24
25
26
27
28 public final class DefaultDependencyNode
29 implements DependencyNode
30 {
31
32 private List<DependencyNode> children;
33
34 private Dependency dependency;
35
36 private Artifact artifact;
37
38 private List<? extends Artifact> relocations;
39
40 private Collection<? extends Artifact> aliases;
41
42 private VersionConstraint versionConstraint;
43
44 private Version version;
45
46 private byte managedBits;
47
48 private List<RemoteRepository> repositories;
49
50 private String context;
51
52 private Map<Object, Object> data;
53
54
55
56
57
58
59 public DefaultDependencyNode( Dependency dependency )
60 {
61 this.dependency = dependency;
62 artifact = ( dependency != null ) ? dependency.getArtifact() : null;
63 children = new ArrayList<DependencyNode>( 0 );
64 aliases = relocations = Collections.emptyList();
65 repositories = Collections.emptyList();
66 context = "";
67 data = Collections.emptyMap();
68 }
69
70
71
72
73
74
75
76
77 public DefaultDependencyNode( Artifact artifact )
78 {
79 this.artifact = artifact;
80 children = new ArrayList<DependencyNode>( 0 );
81 aliases = relocations = Collections.emptyList();
82 repositories = Collections.emptyList();
83 context = "";
84 data = Collections.emptyMap();
85 }
86
87
88
89
90
91
92
93 public DefaultDependencyNode( DependencyNode node )
94 {
95 dependency = node.getDependency();
96 artifact = node.getArtifact();
97 children = new ArrayList<DependencyNode>( 0 );
98 setAliases( node.getAliases() );
99 setRequestContext( node.getRequestContext() );
100 setManagedBits( node.getManagedBits() );
101 setRelocations( node.getRelocations() );
102 setRepositories( node.getRepositories() );
103 setVersion( node.getVersion() );
104 setVersionConstraint( node.getVersionConstraint() );
105 Map<?, ?> data = node.getData();
106 setData( data.isEmpty() ? null : new HashMap<Object, Object>( data ) );
107 }
108
109 public List<DependencyNode> getChildren()
110 {
111 return children;
112 }
113
114 public void setChildren( List<DependencyNode> children )
115 {
116 if ( children == null )
117 {
118 this.children = new ArrayList<DependencyNode>( 0 );
119 }
120 else
121 {
122 this.children = children;
123 }
124 }
125
126 public Dependency getDependency()
127 {
128 return dependency;
129 }
130
131 public Artifact getArtifact()
132 {
133 return artifact;
134 }
135
136 public void setArtifact( Artifact artifact )
137 {
138 if ( dependency == null )
139 {
140 throw new UnsupportedOperationException( "node does not have a dependency" );
141 }
142 dependency = dependency.setArtifact( artifact );
143 this.artifact = dependency.getArtifact();
144 }
145
146 public List<? extends Artifact> getRelocations()
147 {
148 return relocations;
149 }
150
151
152
153
154
155
156 public void setRelocations( List<? extends Artifact> relocations )
157 {
158 if ( relocations == null || relocations.isEmpty() )
159 {
160 this.relocations = Collections.emptyList();
161 }
162 else
163 {
164 this.relocations = relocations;
165 }
166 }
167
168 public Collection<? extends Artifact> getAliases()
169 {
170 return aliases;
171 }
172
173
174
175
176
177
178 public void setAliases( Collection<? extends Artifact> aliases )
179 {
180 if ( aliases == null || aliases.isEmpty() )
181 {
182 this.aliases = Collections.emptyList();
183 }
184 else
185 {
186 this.aliases = aliases;
187 }
188 }
189
190 public VersionConstraint getVersionConstraint()
191 {
192 return versionConstraint;
193 }
194
195
196
197
198
199
200 public void setVersionConstraint( VersionConstraint versionConstraint )
201 {
202 this.versionConstraint = versionConstraint;
203 }
204
205 public Version getVersion()
206 {
207 return version;
208 }
209
210
211
212
213
214
215 public void setVersion( Version version )
216 {
217 this.version = version;
218 }
219
220 public void setScope( String scope )
221 {
222 if ( dependency == null )
223 {
224 throw new UnsupportedOperationException( "node does not have a dependency" );
225 }
226 dependency = dependency.setScope( scope );
227 }
228
229 public void setOptional( Boolean optional )
230 {
231 if ( dependency == null )
232 {
233 throw new UnsupportedOperationException( "node does not have a dependency" );
234 }
235 dependency = dependency.setOptional( optional );
236 }
237
238 public int getManagedBits()
239 {
240 return managedBits;
241 }
242
243
244
245
246
247
248
249 public void setManagedBits( int managedBits )
250 {
251 this.managedBits = (byte) ( managedBits & 0x1F );
252 }
253
254 public List<RemoteRepository> getRepositories()
255 {
256 return repositories;
257 }
258
259
260
261
262
263
264 public void setRepositories( List<RemoteRepository> repositories )
265 {
266 if ( repositories == null || repositories.isEmpty() )
267 {
268 this.repositories = Collections.emptyList();
269 }
270 else
271 {
272 this.repositories = repositories;
273 }
274 }
275
276 public String getRequestContext()
277 {
278 return context;
279 }
280
281 public void setRequestContext( String context )
282 {
283 this.context = ( context != null ) ? context : "";
284 }
285
286 public Map<Object, Object> getData()
287 {
288 return data;
289 }
290
291 public void setData( Map<Object, Object> data )
292 {
293 if ( data == null )
294 {
295 this.data = Collections.emptyMap();
296 }
297 else
298 {
299 this.data = data;
300 }
301 }
302
303 public void setData( Object key, Object value )
304 {
305 if ( key == null )
306 {
307 throw new IllegalArgumentException( "key must not be null" );
308 }
309
310 if ( value == null )
311 {
312 if ( !data.isEmpty() )
313 {
314 data.remove( key );
315
316 if ( data.isEmpty() )
317 {
318 data = Collections.emptyMap();
319 }
320 }
321 }
322 else
323 {
324 if ( data.isEmpty() )
325 {
326 data = new HashMap<Object, Object>( 1, 2 );
327 }
328 data.put( key, value );
329 }
330 }
331
332 public boolean accept( DependencyVisitor visitor )
333 {
334 if ( visitor.visitEnter( this ) )
335 {
336 for ( DependencyNode child : children )
337 {
338 if ( !child.accept( visitor ) )
339 {
340 break;
341 }
342 }
343 }
344
345 return visitor.visitLeave( this );
346 }
347
348 @Override
349 public String toString()
350 {
351 Dependency dep = getDependency();
352 if ( dep == null )
353 {
354 return String.valueOf( getArtifact() );
355 }
356 return dep.toString();
357 }
358
359 }