1 package org.apache.maven.plugins.dependency.tree;
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22 import java.util.ArrayList;
23 import java.util.List;
24 import java.util.Stack;
25
26 import org.apache.maven.artifact.Artifact;
27 import org.apache.maven.model.Exclusion;
28 import org.apache.maven.shared.dependency.graph.DependencyNode;
29 import org.apache.maven.shared.dependency.graph.traversal.DependencyNodeVisitor;
30
31
32
33
34
35
36
37 public class BuildingDependencyNodeVisitor
38 implements DependencyNodeVisitor
39 {
40
41
42
43
44
45 private final DependencyNodeVisitor visitor;
46
47
48
49
50 private final Stack<DependencyNode> parentNodes;
51
52
53
54
55 private DependencyNode rootNode;
56
57
58
59
60
61
62 public BuildingDependencyNodeVisitor()
63 {
64 this( null );
65 }
66
67
68
69
70
71
72
73
74 public BuildingDependencyNodeVisitor( DependencyNodeVisitor visitor )
75 {
76 this.visitor = visitor;
77
78 parentNodes = new Stack<DependencyNode>();
79 }
80
81
82
83
84
85
86 @Override
87 public boolean visit( DependencyNode node )
88 {
89
90 WrapperNode newNode = new WrapperNode(
91 parentNodes.isEmpty() ? null : parentNodes.peek(),
92 node.getArtifact(),
93 node.getPremanagedVersion(),
94 node.getPremanagedScope(),
95 node.getVersionConstraint(),
96 node.getOptional(),
97 node.getExclusions(),
98 node.toNodeString()
99 );
100 newNode.setChildren( new ArrayList<DependencyNode>() );
101
102 if ( parentNodes.empty() )
103 {
104 rootNode = newNode;
105 }
106 else
107 {
108 DependencyNode parentNode = parentNodes.peek();
109 parentNode.getChildren().add( newNode );
110 }
111
112 parentNodes.push( newNode );
113
114 return true;
115 }
116
117
118
119
120 @Override
121 public boolean endVisit( DependencyNode node )
122 {
123 parentNodes.pop();
124
125
126 if ( parentNodes.empty() && visitor != null )
127 {
128 rootNode.accept( visitor );
129 }
130
131 return true;
132 }
133
134
135
136
137
138
139
140
141 public DependencyNodeVisitor getDependencyNodeVisitor()
142 {
143 return visitor;
144 }
145
146
147
148
149
150
151 public DependencyNode getDependencyTree()
152 {
153 return rootNode;
154 }
155
156 private static class WrapperNode implements DependencyNode
157 {
158
159 private final Artifact artifact;
160
161 private final DependencyNode parent;
162
163 private final String premanagedVersion;
164
165 private final String premanagedScope;
166
167 private final String versionConstraint;
168
169 private List<DependencyNode> children;
170
171 private final Boolean optional;
172
173 private final List<Exclusion> exclusions;
174
175 private final String nodeString;
176
177 private WrapperNode( DependencyNode parent,
178 Artifact artifact,
179 String premanagedVersion,
180 String premanagedScope,
181 String versionConstraint,
182 Boolean optional,
183 List<Exclusion> exclusions,
184 String nodeString )
185 {
186 this.artifact = artifact;
187 this.parent = parent;
188 this.premanagedVersion = premanagedVersion;
189 this.premanagedScope = premanagedScope;
190 this.versionConstraint = versionConstraint;
191 this.optional = optional;
192 this.exclusions = exclusions;
193 this.nodeString = nodeString;
194 }
195
196 @Override
197 public Artifact getArtifact()
198 {
199 return artifact;
200 }
201
202 @Override
203 public List<DependencyNode> getChildren()
204 {
205 return children;
206 }
207
208 @Override
209 public boolean accept( DependencyNodeVisitor visitor )
210 {
211 if ( visitor.visit( this ) )
212 {
213 for ( DependencyNode child : getChildren() )
214 {
215 if ( !child.accept( visitor ) )
216 {
217 break;
218 }
219 }
220 }
221
222 return visitor.endVisit( this );
223 }
224
225 @Override
226 public DependencyNode getParent()
227 {
228 return parent;
229 }
230
231 @Override
232 public String getPremanagedVersion()
233 {
234 return premanagedVersion;
235 }
236
237 @Override
238 public String getPremanagedScope()
239 {
240 return premanagedScope;
241 }
242
243 @Override
244 public String getVersionConstraint()
245 {
246 return versionConstraint;
247 }
248
249 @Override
250 public String toNodeString()
251 {
252 return nodeString;
253 }
254
255 @Override
256 public Boolean getOptional()
257 {
258 return optional;
259 }
260
261 @Override
262 public List<Exclusion> getExclusions()
263 {
264 return exclusions;
265 }
266
267 public void setChildren( List<DependencyNode> children )
268 {
269 this.children = children;
270 }
271 }
272 }