1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
|
/*******************************************************************************
* Copyright (c) 2009, 2018 Mountainminds GmbH & Co. KG and Contributors
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Marc R. Hoffmann - initial API and implementation
*
*******************************************************************************/
package org.jacoco.core.analysis;
/**
* Interface for hierarchical coverage data nodes with different coverage
* counters.
*/
public interface ICoverageNode {
/**
* Type of a Java element represented by a {@link ICoverageNode} instance.
*/
enum ElementType {
/** Method */
METHOD,
/** Class */
CLASS,
/** Source File */
SOURCEFILE,
/** Java Package */
PACKAGE,
/** Bundle of Packages */
BUNDLE,
/** Logical Group of Bundles */
GROUP,
}
/**
* Different counter types supported by JaCoCo.
*/
enum CounterEntity {
/** Counter for instructions */
INSTRUCTION,
/** Counter for branches */
BRANCH,
/** Counter for source lines */
LINE,
/** Counter for cyclomatic complexity */
COMPLEXITY,
/** Counter for methods */
METHOD,
/** Counter for classes */
CLASS
}
/**
* Returns the type of element represented by this node.
*
* @return type of this node
*/
ElementType getElementType();
/**
* Returns the name of this node.
*
* @return name of this node
*/
String getName();
/**
* Returns the counter for byte code instructions.
*
* @return counter for instructions
*/
ICounter getInstructionCounter();
/**
* Returns the counter for branches.
*
* @return counter for branches
*/
ICounter getBranchCounter();
/**
* Returns the counter for lines.
*
* @return counter for lines
*/
ICounter getLineCounter();
/**
* Returns the counter for cyclomatic complexity.
*
* @return counter for complexity
*/
ICounter getComplexityCounter();
/**
* Returns the counter for methods.
*
* @return counter for methods
*/
ICounter getMethodCounter();
/**
* Returns the counter for classes.
*
* @return counter for classes
*/
ICounter getClassCounter();
/**
* Generic access to the the counters.
*
* @param entity
* entity we're we want to have the counter for
* @return counter for the given entity
*/
ICounter getCounter(CounterEntity entity);
/**
* Creates a plain copy of this node. While {@link ICoverageNode}
* implementations may contain heavy data structures, the copy returned by
* this method is reduced to the counters only. This helps to save memory
* while processing huge structures.
*
* @return copy with counters only
*/
ICoverageNode getPlainCopy();
}
|
