CoverageNodeImpl.java revision 283abfa148b749678924b5e75eabd35a2d58f9f8 
1/*******************************************************************************
2 * Copyright (c) 2009, 2014 Mountainminds GmbH & Co. KG and Contributors
3 * All rights reserved. This program and the accompanying materials
4 * are made available under the terms of the Eclipse Public License v1.0
5 * which accompanies this distribution, and is available at
6 * http://www.eclipse.org/legal/epl-v10.html
7 *
8 * Contributors:
9 *    Marc R. Hoffmann - initial API and implementation
10 *
11 *******************************************************************************/
12package org.jacoco.core.analysis;
13
14import java.util.Collection;
15
16import org.jacoco.core.internal.analysis.CounterImpl;
17
18/**
19 * Base implementation for coverage data nodes.
20 */
21public class CoverageNodeImpl implements ICoverageNode {
22
23	private final ElementType elementType;
24
25	private final String name;
26
27	/** Counter for branches. */
28	protected CounterImpl branchCounter;
29
30	/** Counter for instructions. */
31	protected CounterImpl instructionCounter;
32
33	/** Counter for lines */
34	protected CounterImpl lineCounter;
35
36	/** Counter for complexity. */
37	protected CounterImpl complexityCounter;
38
39	/** Counter for methods. */
40	protected CounterImpl methodCounter;
41
42	/** Counter for classes. */
43	protected CounterImpl classCounter;
44
45	/**
46	 * Creates a new coverage data node.
47	 *
48	 * @param elementType
49	 *            type of the element represented by this instance
50	 * @param name
51	 *            name of this node
52	 */
53	public CoverageNodeImpl(final ElementType elementType, final String name) {
54		this.elementType = elementType;
55		this.name = name;
56		this.branchCounter = CounterImpl.COUNTER_0_0;
57		this.instructionCounter = CounterImpl.COUNTER_0_0;
58		this.complexityCounter = CounterImpl.COUNTER_0_0;
59		this.methodCounter = CounterImpl.COUNTER_0_0;
60		this.classCounter = CounterImpl.COUNTER_0_0;
61		this.lineCounter = CounterImpl.COUNTER_0_0;
62	}
63
64	/**
65	 * Increments the counters by the values given by another element.
66	 *
67	 * @param child
68	 *            counters to add
69	 */
70	public void increment(final ICoverageNode child) {
71		instructionCounter = instructionCounter.increment(child
72				.getInstructionCounter());
73		branchCounter = branchCounter.increment(child.getBranchCounter());
74		lineCounter = lineCounter.increment(child.getLineCounter());
75		complexityCounter = complexityCounter.increment(child
76				.getComplexityCounter());
77		methodCounter = methodCounter.increment(child.getMethodCounter());
78		classCounter = classCounter.increment(child.getClassCounter());
79	}
80
81	/**
82	 * Increments the counters by the values given by the collection of
83	 * elements.
84	 *
85	 * @param children
86	 *            list of nodes, which counters will be added to this node
87	 */
88	public void increment(final Collection<? extends ICoverageNode> children) {
89		for (final ICoverageNode child : children) {
90			increment(child);
91		}
92	}
93
94	// === ICoverageDataNode ===
95
96	public ElementType getElementType() {
97		return elementType;
98	}
99
100	public String getName() {
101		return name;
102	}
103
104	public ICounter getInstructionCounter() {
105		return instructionCounter;
106	}
107
108	public ICounter getBranchCounter() {
109		return branchCounter;
110	}
111
112	public ICounter getLineCounter() {
113		return lineCounter;
114	}
115
116	public ICounter getComplexityCounter() {
117		return complexityCounter;
118	}
119
120	public ICounter getMethodCounter() {
121		return methodCounter;
122	}
123
124	public ICounter getClassCounter() {
125		return classCounter;
126	}
127
128	public ICounter getCounter(final CounterEntity entity) {
129		switch (entity) {
130		case INSTRUCTION:
131			return getInstructionCounter();
132		case BRANCH:
133			return getBranchCounter();
134		case LINE:
135			return getLineCounter();
136		case COMPLEXITY:
137			return getComplexityCounter();
138		case METHOD:
139			return getMethodCounter();
140		case CLASS:
141			return getClassCounter();
142		}
143		throw new AssertionError(entity);
144	}
145
146	public ICoverageNode getPlainCopy() {
147		final CoverageNodeImpl copy = new CoverageNodeImpl(elementType, name);
148		copy.instructionCounter = CounterImpl.getInstance(instructionCounter);
149		copy.branchCounter = CounterImpl.getInstance(branchCounter);
150		copy.lineCounter = CounterImpl.getInstance(lineCounter);
151		copy.complexityCounter = CounterImpl.getInstance(complexityCounter);
152		copy.methodCounter = CounterImpl.getInstance(methodCounter);
153		copy.classCounter = CounterImpl.getInstance(classCounter);
154		return copy;
155	}
156
157	@Override
158	public String toString() {
159		final StringBuilder sb = new StringBuilder();
160		sb.append(name).append(" [").append(elementType).append("]");
161		return sb.toString();
162	}
163
164}
165