Coverage Report

Coverage Report - com.jeantessier.dependency.VisitorBase

Classes in this File

Line Coverage

Branch Coverage

Complexity

VisitorBase

90%

96/106

76%

43/56

1.903

 /*
  *  Copyright (c) 2001-2009, Jean Tessier
  *  All rights reserved.
  *  
  *  Redistribution and use in source and binary forms, with or without
  *  modification, are permitted provided that the following conditions
  *  are met:
  *  
  *      * Redistributions of source code must retain the above copyright
  *        notice, this list of conditions and the following disclaimer.
  *  
  *      * Redistributions in binary form must reproduce the above copyright
  *        notice, this list of conditions and the following disclaimer in the
  *        documentation and/or other materials provided with the distribution.
  *  
  *      * Neither the name of Jean Tessier nor the names of his contributors
  *        may be used to endorse or promote products derived from this software
  *        without specific prior written permission.
  *  
  *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  *  A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR
  *  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  *  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  *  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  *  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  *  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  *  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  *  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 package com.jeantessier.dependency;
 
 import java.util.*;
 
 import org.apache.log4j.*;
 
 /**
  *  This is a basic implementation of Visitor.
  *
  *  @see Visitor
  *  @author Jean Tessier
  */
 public abstract class VisitorBase implements Visitor {
     private TraversalStrategy strategy;
 
     private LinkedList<Node> currentNodes = new LinkedList<Node>();
 
     public VisitorBase() {
         this(new ComprehensiveTraversalStrategy());
     }
 
     public VisitorBase(TraversalStrategy strategy) {
         this.strategy = strategy;
     }
 
     protected TraversalStrategy getStrategy() {
         return strategy;
     }
 
     public void traverseNodes(Collection<? extends Node> nodes) {
         if (Logger.getLogger(getClass()).isDebugEnabled()) {
             Logger.getLogger(getClass()).debug("nodes = " + nodes);
         }
 
         for (Node node : getStrategy().order(nodes)) {
             node.accept(this);
         }
     }
 
     public void traverseInbound(Collection<? extends Node> nodes) {
         for (Node node : getStrategy().order(nodes)) {
             node.acceptInbound(this);
         }
     }
 
     public void traverseOutbound(Collection<? extends Node> nodes) {
         for (Node node : getStrategy().order(nodes)) {
             node.acceptOutbound(this);
         }
     }
 
     protected Node getCurrentNode() {
         Node result = null;
 
         if (!currentNodes.isEmpty()) {
             result = currentNodes.getLast();
         }
 
         if (Logger.getLogger(getClass()).isDebugEnabled()) {
             Logger.getLogger(getClass()).debug(currentNodes + ": " + result);
         }
 
         return result;
     }
 
     protected void pushNode(Node currentNode) {
         if (Logger.getLogger(getClass()).isDebugEnabled()) {
             Logger.getLogger(getClass()).debug(currentNodes + " + " + currentNode);
         }
 
         currentNodes.addLast(currentNode);
     }
 
     protected Node popNode() {
         Node result = currentNodes.removeLast();
 
         if (Logger.getLogger(getClass()).isDebugEnabled()) {
             Logger.getLogger(getClass()).debug(currentNodes + " -> " + result);
         }
 
         return result;
     }
 
     public void visitPackageNode(PackageNode node) {
         boolean inScope = isInScope(node);
         
         if (inScope) {
             preprocessPackageNode(node);
             
             if (getStrategy().doPreOutboundTraversal()) {
                 traverseOutbound(node.getOutboundDependencies());
             }
             
             if (getStrategy().doPreInboundTraversal()) {
                 traverseInbound(node.getInboundDependencies());
             }
             
             preprocessAfterDependenciesPackageNode(node);
         }
             
         traverseNodes(node.getClasses());
 
         if (inScope) {
             postprocessBeforeDependenciesPackageNode(node);
 
             if (getStrategy().doPostOutboundTraversal()) {
                 traverseOutbound(node.getOutboundDependencies());
             }
             
             if (getStrategy().doPostInboundTraversal()) {
                 traverseInbound(node.getInboundDependencies());
             }
             
             postprocessPackageNode(node);
         }
     }
 
     protected boolean isInScope(PackageNode node) {
         return getStrategy().isInScope(node);
     }
 
     protected void preprocessPackageNode(PackageNode node) {
         pushNode(node);
     }
     
     protected void preprocessAfterDependenciesPackageNode(PackageNode node) {
         // Do nothing
     }
     
     protected void postprocessBeforeDependenciesPackageNode(PackageNode node) {
         // Do nothing
     }
     
     protected void postprocessPackageNode(PackageNode node) {
         if (node.equals(getCurrentNode())) {
             popNode();
         }
     }
     
     public void visitInboundPackageNode(PackageNode node) {
         // Do nothing
     }
 
     public void visitOutboundPackageNode(PackageNode node) {
         // Do nothing
     }
 
     public void visitClassNode(ClassNode node) {
         boolean inScope = isInScope(node);
         
         if (inScope) {
             preprocessClassNode(node);
             
             if (getStrategy().doPreOutboundTraversal()) {
                 traverseOutbound(node.getOutboundDependencies());
             }
             
             if (getStrategy().doPreInboundTraversal()) {
                 traverseInbound(node.getInboundDependencies());
             }
 
             preprocessAfterDependenciesClassNode(node);
         }
         
         traverseNodes(node.getFeatures());
             
         if (inScope) {
             postprocessBeforeDependenciesClassNode(node);
 
             if (getStrategy().doPostOutboundTraversal()) {
                 traverseOutbound(node.getOutboundDependencies());
             }
             
             if (getStrategy().doPostInboundTraversal()) {
                 traverseInbound(node.getInboundDependencies());
             }
             
             postprocessClassNode(node);
         }
     }
 
     protected boolean isInScope(ClassNode node) {
         return getStrategy().isInScope(node);
     }
 
     protected void preprocessClassNode(ClassNode node) {
         pushNode(node);
     }
     
     protected void preprocessAfterDependenciesClassNode(ClassNode node) {
         // Do nothing
     }
 
     protected void postprocessBeforeDependenciesClassNode(ClassNode node) {
         // Do nothing
     }
 
     protected void postprocessClassNode(ClassNode node) {
         if (node.equals(getCurrentNode())) {
             popNode();
         }
     }
 
     public void visitInboundClassNode(ClassNode node) {
         // Do nothing
     }
 
     public void visitOutboundClassNode(ClassNode node) {
         // Do nothing
     }
 
     public void visitFeatureNode(FeatureNode node) {
         if (isInScope(node)) {
             preprocessFeatureNode(node);
             
             if (getStrategy().doPreOutboundTraversal()) {
                 traverseOutbound(node.getOutboundDependencies());
             }
             
             if (getStrategy().doPreInboundTraversal()) {
                 traverseInbound(node.getInboundDependencies());
             }
             
             if (getStrategy().doPostOutboundTraversal()) {
                 traverseOutbound(node.getOutboundDependencies());
             }
             
             if (getStrategy().doPostInboundTraversal()) {
                 traverseInbound(node.getInboundDependencies());
             }
             
             postprocessFeatureNode(node);
         }
     }
 
     protected boolean isInScope(FeatureNode node) {
         return getStrategy().isInScope(node);
     }
 
     protected void preprocessFeatureNode(FeatureNode node) {
         pushNode(node);
     }
     
     protected void postprocessFeatureNode(FeatureNode node) {
         if (node.equals(getCurrentNode())) {
             popNode();
         }
     }
 
     public void visitInboundFeatureNode(FeatureNode node) {
         // Do nothing
     }
 
     public void visitOutboundFeatureNode(FeatureNode node) {
         // Do nothing
     }
 }

1		/*
2		* Copyright (c) 2001-2009, Jean Tessier
3		* All rights reserved.
4		*
5		* Redistribution and use in source and binary forms, with or without
6		* modification, are permitted provided that the following conditions
7		* are met:
8		*
9		* * Redistributions of source code must retain the above copyright
10		* notice, this list of conditions and the following disclaimer.
11		*
12		* * Redistributions in binary form must reproduce the above copyright
13		* notice, this list of conditions and the following disclaimer in the
14		* documentation and/or other materials provided with the distribution.
15		*
16		* * Neither the name of Jean Tessier nor the names of his contributors
17		* may be used to endorse or promote products derived from this software
18		* without specific prior written permission.
19		*
20		* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
21		* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
22		* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
23		* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR
24		* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
25		* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
26		* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
27		* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
28		* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
29		* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
30		* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31		*/
32
33		package com.jeantessier.dependency;
34
35		import java.util.*;
36
37		import org.apache.log4j.*;
38
39		/**
40		* This is a basic implementation of Visitor.
41		*
42		* @see Visitor
43		* @author Jean Tessier
44		*/
45		public abstract class VisitorBase implements Visitor {
46		private TraversalStrategy strategy;
47
48	362	private LinkedList<Node> currentNodes = new LinkedList<Node>();
49
50		public VisitorBase() {
51	94	this(new ComprehensiveTraversalStrategy());
52	94	}
53
54	362	public VisitorBase(TraversalStrategy strategy) {
55	362	this.strategy = strategy;
56	362	}
57
58		protected TraversalStrategy getStrategy() {
59	22314	return strategy;
60		}
61
62		public void traverseNodes(Collection<? extends Node> nodes) {
63	2433	if (Logger.getLogger(getClass()).isDebugEnabled()) {
64	0	Logger.getLogger(getClass()).debug("nodes = " + nodes);
65		}
66
67	2433	for (Node node : getStrategy().order(nodes)) {
68	2935	node.accept(this);
69		}
70	2433	}
71
72		public void traverseInbound(Collection<? extends Node> nodes) {
73	2321	for (Node node : getStrategy().order(nodes)) {
74	958	node.acceptInbound(this);
75		}
76	2321	}
77
78		public void traverseOutbound(Collection<? extends Node> nodes) {
79	3701	for (Node node : getStrategy().order(nodes)) {
80	1584	node.acceptOutbound(this);
81		}
82	3701	}
83
84		protected Node getCurrentNode() {
85	4003	Node result = null;
86
87	4003	if (!currentNodes.isEmpty()) {
88	3996	result = currentNodes.getLast();
89		}
90
91	4003	if (Logger.getLogger(getClass()).isDebugEnabled()) {
92	0	Logger.getLogger(getClass()).debug(currentNodes + ": " + result);
93		}
94
95	4003	return result;
96		}
97
98		protected void pushNode(Node currentNode) {
99	2350	if (Logger.getLogger(getClass()).isDebugEnabled()) {
100	0	Logger.getLogger(getClass()).debug(currentNodes + " + " + currentNode);
101		}
102
103	2350	currentNodes.addLast(currentNode);
104	2350	}
105
106		protected Node popNode() {
107	2223	Node result = currentNodes.removeLast();
108
109	2223	if (Logger.getLogger(getClass()).isDebugEnabled()) {
110	0	Logger.getLogger(getClass()).debug(currentNodes + " -> " + result);
111		}
112
113	2223	return result;
114		}
115
116		public void visitPackageNode(PackageNode node) {
117	1080	boolean inScope = isInScope(node);
118
119	1080	if (inScope) {
120	935	preprocessPackageNode(node);
121
122	935	if (getStrategy().doPreOutboundTraversal()) {
123	869	traverseOutbound(node.getOutboundDependencies());
124		}
125
126	935	if (getStrategy().doPreInboundTraversal()) {
127	869	traverseInbound(node.getInboundDependencies());
128		}
129
130	935	preprocessAfterDependenciesPackageNode(node);
131		}
132
133	1080	traverseNodes(node.getClasses());
134
135	1080	if (inScope) {
136	935	postprocessBeforeDependenciesPackageNode(node);
137
138	935	if (getStrategy().doPostOutboundTraversal()) {
139	0	traverseOutbound(node.getOutboundDependencies());
140		}
141
142	935	if (getStrategy().doPostInboundTraversal()) {
143	0	traverseInbound(node.getInboundDependencies());
144		}
145
146	935	postprocessPackageNode(node);
147		}
148	1080	}
149
150		protected boolean isInScope(PackageNode node) {
151	813	return getStrategy().isInScope(node);
152		}
153
154		protected void preprocessPackageNode(PackageNode node) {
155	829	pushNode(node);
156	829	}
157
158		protected void preprocessAfterDependenciesPackageNode(PackageNode node) {
159		// Do nothing
160	563	}
161
162		protected void postprocessBeforeDependenciesPackageNode(PackageNode node) {
163		// Do nothing
164	935	}
165
166		protected void postprocessPackageNode(PackageNode node) {
167	772	if (node.equals(getCurrentNode())) {
168	772	popNode();
169		}
170	772	}
171
172		public void visitInboundPackageNode(PackageNode node) {
173		// Do nothing
174	171	}
175
176		public void visitOutboundPackageNode(PackageNode node) {
177		// Do nothing
178	350	}
179
180		public void visitClassNode(ClassNode node) {
181	1016	boolean inScope = isInScope(node);
182
183	1016	if (inScope) {
184	873	preprocessClassNode(node);
185
186	873	if (getStrategy().doPreOutboundTraversal()) {
187	783	traverseOutbound(node.getOutboundDependencies());
188		}
189
190	873	if (getStrategy().doPreInboundTraversal()) {
191	783	traverseInbound(node.getInboundDependencies());
192		}
193
194	873	preprocessAfterDependenciesClassNode(node);
195		}
196
197	1016	traverseNodes(node.getFeatures());
198
199	1016	if (inScope) {
200	873	postprocessBeforeDependenciesClassNode(node);
201
202	873	if (getStrategy().doPostOutboundTraversal()) {
203	0	traverseOutbound(node.getOutboundDependencies());
204		}
205
206	873	if (getStrategy().doPostInboundTraversal()) {
207	0	traverseInbound(node.getInboundDependencies());
208		}
209
210	873	postprocessClassNode(node);
211		}
212	1016	}
213
214		protected boolean isInScope(ClassNode node) {
215	718	return getStrategy().isInScope(node);
216		}
217
218		protected void preprocessClassNode(ClassNode node) {
219	698	pushNode(node);
220	698	}
221
222		protected void preprocessAfterDependenciesClassNode(ClassNode node) {
223		// Do nothing
224	593	}
225
226		protected void postprocessBeforeDependenciesClassNode(ClassNode node) {
227		// Do nothing
228	873	}
229
230		protected void postprocessClassNode(ClassNode node) {
231	656	if (node.equals(getCurrentNode())) {
232	656	popNode();
233		}
234	656	}
235
236		public void visitInboundClassNode(ClassNode node) {
237		// Do nothing
238	55	}
239
240		public void visitOutboundClassNode(ClassNode node) {
241		// Do nothing
242	348	}
243
244		public void visitFeatureNode(FeatureNode node) {
245	859	if (isInScope(node)) {
246	747	preprocessFeatureNode(node);
247
248	747	if (getStrategy().doPreOutboundTraversal()) {
249	669	traverseOutbound(node.getOutboundDependencies());
250		}
251
252	747	if (getStrategy().doPreInboundTraversal()) {
253	669	traverseInbound(node.getInboundDependencies());
254		}
255
256	747	if (getStrategy().doPostOutboundTraversal()) {
257	0	traverseOutbound(node.getOutboundDependencies());
258		}
259
260	747	if (getStrategy().doPostInboundTraversal()) {
261	0	traverseInbound(node.getInboundDependencies());
262		}
263
264	747	postprocessFeatureNode(node);
265		}
266	859	}
267
268		protected boolean isInScope(FeatureNode node) {
269	566	return getStrategy().isInScope(node);
270		}
271
272		protected void preprocessFeatureNode(FeatureNode node) {
273	646	pushNode(node);
274	646	}
275
276		protected void postprocessFeatureNode(FeatureNode node) {
277	618	if (node.equals(getCurrentNode())) {
278	618	popNode();
279		}
280	618	}
281
282		public void visitInboundFeatureNode(FeatureNode node) {
283		// Do nothing
284	64	}
285
286		public void visitOutboundFeatureNode(FeatureNode node) {
287		// Do nothing
288	351	}
289		}